#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct UpdateSubnetGroupError {
pub kind: UpdateSubnetGroupErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for UpdateSubnetGroupError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: UpdateSubnetGroupErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum UpdateSubnetGroupErrorKind {
InvalidSubnet(crate::error::InvalidSubnet),
ServiceLinkedRoleNotFoundFault(crate::error::ServiceLinkedRoleNotFoundFault),
SubnetGroupNotFoundFault(crate::error::SubnetGroupNotFoundFault),
SubnetInUse(crate::error::SubnetInUse),
SubnetQuotaExceededFault(crate::error::SubnetQuotaExceededFault),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for UpdateSubnetGroupError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
UpdateSubnetGroupErrorKind::InvalidSubnet(_inner) => _inner.fmt(f),
UpdateSubnetGroupErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => _inner.fmt(f),
UpdateSubnetGroupErrorKind::SubnetGroupNotFoundFault(_inner) => _inner.fmt(f),
UpdateSubnetGroupErrorKind::SubnetInUse(_inner) => _inner.fmt(f),
UpdateSubnetGroupErrorKind::SubnetQuotaExceededFault(_inner) => _inner.fmt(f),
UpdateSubnetGroupErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for UpdateSubnetGroupError {
fn code(&self) -> Option<&str> {
UpdateSubnetGroupError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl UpdateSubnetGroupError {
pub fn new(kind: UpdateSubnetGroupErrorKind, meta: aws_smithy_types::Error) -> Self {
Self { kind, meta }
}
pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
Self {
kind: UpdateSubnetGroupErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: UpdateSubnetGroupErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
}
}
pub fn message(&self) -> Option<&str> {
self.meta.message()
}
pub fn meta(&self) -> &aws_smithy_types::Error {
&self.meta
}
pub fn request_id(&self) -> Option<&str> {
self.meta.request_id()
}
pub fn code(&self) -> Option<&str> {
self.meta.code()
}
pub fn is_invalid_subnet(&self) -> bool {
matches!(&self.kind, UpdateSubnetGroupErrorKind::InvalidSubnet(_))
}
pub fn is_service_linked_role_not_found_fault(&self) -> bool {
matches!(
&self.kind,
UpdateSubnetGroupErrorKind::ServiceLinkedRoleNotFoundFault(_)
)
}
pub fn is_subnet_group_not_found_fault(&self) -> bool {
matches!(
&self.kind,
UpdateSubnetGroupErrorKind::SubnetGroupNotFoundFault(_)
)
}
pub fn is_subnet_in_use(&self) -> bool {
matches!(&self.kind, UpdateSubnetGroupErrorKind::SubnetInUse(_))
}
pub fn is_subnet_quota_exceeded_fault(&self) -> bool {
matches!(
&self.kind,
UpdateSubnetGroupErrorKind::SubnetQuotaExceededFault(_)
)
}
}
impl std::error::Error for UpdateSubnetGroupError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
UpdateSubnetGroupErrorKind::InvalidSubnet(_inner) => Some(_inner),
UpdateSubnetGroupErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => Some(_inner),
UpdateSubnetGroupErrorKind::SubnetGroupNotFoundFault(_inner) => Some(_inner),
UpdateSubnetGroupErrorKind::SubnetInUse(_inner) => Some(_inner),
UpdateSubnetGroupErrorKind::SubnetQuotaExceededFault(_inner) => Some(_inner),
UpdateSubnetGroupErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct SubnetQuotaExceededFault {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl SubnetQuotaExceededFault {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for SubnetQuotaExceededFault {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "SubnetQuotaExceededFault")?;
if let Some(inner_1) = &self.message {
{
write!(f, ": {}", inner_1)?;
}
}
Ok(())
}
}
impl std::error::Error for SubnetQuotaExceededFault {}
pub mod subnet_quota_exceeded_fault {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::SubnetQuotaExceededFault {
crate::error::SubnetQuotaExceededFault {
message: self.message,
}
}
}
}
impl SubnetQuotaExceededFault {
pub fn builder() -> crate::error::subnet_quota_exceeded_fault::Builder {
crate::error::subnet_quota_exceeded_fault::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct SubnetInUse {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl SubnetInUse {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for SubnetInUse {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "SubnetInUse")?;
if let Some(inner_2) = &self.message {
{
write!(f, ": {}", inner_2)?;
}
}
Ok(())
}
}
impl std::error::Error for SubnetInUse {}
pub mod subnet_in_use {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::SubnetInUse {
crate::error::SubnetInUse {
message: self.message,
}
}
}
}
impl SubnetInUse {
pub fn builder() -> crate::error::subnet_in_use::Builder {
crate::error::subnet_in_use::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct SubnetGroupNotFoundFault {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl SubnetGroupNotFoundFault {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for SubnetGroupNotFoundFault {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "SubnetGroupNotFoundFault")?;
if let Some(inner_3) = &self.message {
{
write!(f, ": {}", inner_3)?;
}
}
Ok(())
}
}
impl std::error::Error for SubnetGroupNotFoundFault {}
pub mod subnet_group_not_found_fault {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::SubnetGroupNotFoundFault {
crate::error::SubnetGroupNotFoundFault {
message: self.message,
}
}
}
}
impl SubnetGroupNotFoundFault {
pub fn builder() -> crate::error::subnet_group_not_found_fault::Builder {
crate::error::subnet_group_not_found_fault::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ServiceLinkedRoleNotFoundFault {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl ServiceLinkedRoleNotFoundFault {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for ServiceLinkedRoleNotFoundFault {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "ServiceLinkedRoleNotFoundFault")?;
if let Some(inner_4) = &self.message {
{
write!(f, ": {}", inner_4)?;
}
}
Ok(())
}
}
impl std::error::Error for ServiceLinkedRoleNotFoundFault {}
pub mod service_linked_role_not_found_fault {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::ServiceLinkedRoleNotFoundFault {
crate::error::ServiceLinkedRoleNotFoundFault {
message: self.message,
}
}
}
}
impl ServiceLinkedRoleNotFoundFault {
pub fn builder() -> crate::error::service_linked_role_not_found_fault::Builder {
crate::error::service_linked_role_not_found_fault::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct InvalidSubnet {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl InvalidSubnet {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for InvalidSubnet {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "InvalidSubnet")?;
if let Some(inner_5) = &self.message {
{
write!(f, ": {}", inner_5)?;
}
}
Ok(())
}
}
impl std::error::Error for InvalidSubnet {}
pub mod invalid_subnet {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::InvalidSubnet {
crate::error::InvalidSubnet {
message: self.message,
}
}
}
}
impl InvalidSubnet {
pub fn builder() -> crate::error::invalid_subnet::Builder {
crate::error::invalid_subnet::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct UpdateParameterGroupError {
pub kind: UpdateParameterGroupErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for UpdateParameterGroupError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: UpdateParameterGroupErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum UpdateParameterGroupErrorKind {
InvalidParameterCombinationException(crate::error::InvalidParameterCombinationException),
InvalidParameterGroupStateFault(crate::error::InvalidParameterGroupStateFault),
InvalidParameterValueException(crate::error::InvalidParameterValueException),
ParameterGroupNotFoundFault(crate::error::ParameterGroupNotFoundFault),
ServiceLinkedRoleNotFoundFault(crate::error::ServiceLinkedRoleNotFoundFault),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for UpdateParameterGroupError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
UpdateParameterGroupErrorKind::InvalidParameterCombinationException(_inner) => {
_inner.fmt(f)
}
UpdateParameterGroupErrorKind::InvalidParameterGroupStateFault(_inner) => _inner.fmt(f),
UpdateParameterGroupErrorKind::InvalidParameterValueException(_inner) => _inner.fmt(f),
UpdateParameterGroupErrorKind::ParameterGroupNotFoundFault(_inner) => _inner.fmt(f),
UpdateParameterGroupErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => _inner.fmt(f),
UpdateParameterGroupErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for UpdateParameterGroupError {
fn code(&self) -> Option<&str> {
UpdateParameterGroupError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl UpdateParameterGroupError {
pub fn new(kind: UpdateParameterGroupErrorKind, meta: aws_smithy_types::Error) -> Self {
Self { kind, meta }
}
pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
Self {
kind: UpdateParameterGroupErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: UpdateParameterGroupErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
}
}
pub fn message(&self) -> Option<&str> {
self.meta.message()
}
pub fn meta(&self) -> &aws_smithy_types::Error {
&self.meta
}
pub fn request_id(&self) -> Option<&str> {
self.meta.request_id()
}
pub fn code(&self) -> Option<&str> {
self.meta.code()
}
pub fn is_invalid_parameter_combination_exception(&self) -> bool {
matches!(
&self.kind,
UpdateParameterGroupErrorKind::InvalidParameterCombinationException(_)
)
}
pub fn is_invalid_parameter_group_state_fault(&self) -> bool {
matches!(
&self.kind,
UpdateParameterGroupErrorKind::InvalidParameterGroupStateFault(_)
)
}
pub fn is_invalid_parameter_value_exception(&self) -> bool {
matches!(
&self.kind,
UpdateParameterGroupErrorKind::InvalidParameterValueException(_)
)
}
pub fn is_parameter_group_not_found_fault(&self) -> bool {
matches!(
&self.kind,
UpdateParameterGroupErrorKind::ParameterGroupNotFoundFault(_)
)
}
pub fn is_service_linked_role_not_found_fault(&self) -> bool {
matches!(
&self.kind,
UpdateParameterGroupErrorKind::ServiceLinkedRoleNotFoundFault(_)
)
}
}
impl std::error::Error for UpdateParameterGroupError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
UpdateParameterGroupErrorKind::InvalidParameterCombinationException(_inner) => {
Some(_inner)
}
UpdateParameterGroupErrorKind::InvalidParameterGroupStateFault(_inner) => Some(_inner),
UpdateParameterGroupErrorKind::InvalidParameterValueException(_inner) => Some(_inner),
UpdateParameterGroupErrorKind::ParameterGroupNotFoundFault(_inner) => Some(_inner),
UpdateParameterGroupErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => Some(_inner),
UpdateParameterGroupErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ParameterGroupNotFoundFault {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl ParameterGroupNotFoundFault {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for ParameterGroupNotFoundFault {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "ParameterGroupNotFoundFault")?;
if let Some(inner_6) = &self.message {
{
write!(f, ": {}", inner_6)?;
}
}
Ok(())
}
}
impl std::error::Error for ParameterGroupNotFoundFault {}
pub mod parameter_group_not_found_fault {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::ParameterGroupNotFoundFault {
crate::error::ParameterGroupNotFoundFault {
message: self.message,
}
}
}
}
impl ParameterGroupNotFoundFault {
pub fn builder() -> crate::error::parameter_group_not_found_fault::Builder {
crate::error::parameter_group_not_found_fault::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct InvalidParameterValueException {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl InvalidParameterValueException {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for InvalidParameterValueException {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "InvalidParameterValueException")?;
if let Some(inner_7) = &self.message {
{
write!(f, ": {}", inner_7)?;
}
}
Ok(())
}
}
impl std::error::Error for InvalidParameterValueException {}
pub mod invalid_parameter_value_exception {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::InvalidParameterValueException {
crate::error::InvalidParameterValueException {
message: self.message,
}
}
}
}
impl InvalidParameterValueException {
pub fn builder() -> crate::error::invalid_parameter_value_exception::Builder {
crate::error::invalid_parameter_value_exception::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct InvalidParameterGroupStateFault {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl InvalidParameterGroupStateFault {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for InvalidParameterGroupStateFault {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "InvalidParameterGroupStateFault")?;
if let Some(inner_8) = &self.message {
{
write!(f, ": {}", inner_8)?;
}
}
Ok(())
}
}
impl std::error::Error for InvalidParameterGroupStateFault {}
pub mod invalid_parameter_group_state_fault {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::InvalidParameterGroupStateFault {
crate::error::InvalidParameterGroupStateFault {
message: self.message,
}
}
}
}
impl InvalidParameterGroupStateFault {
pub fn builder() -> crate::error::invalid_parameter_group_state_fault::Builder {
crate::error::invalid_parameter_group_state_fault::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct InvalidParameterCombinationException {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl InvalidParameterCombinationException {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for InvalidParameterCombinationException {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "InvalidParameterCombinationException")?;
if let Some(inner_9) = &self.message {
{
write!(f, ": {}", inner_9)?;
}
}
Ok(())
}
}
impl std::error::Error for InvalidParameterCombinationException {}
pub mod invalid_parameter_combination_exception {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::InvalidParameterCombinationException {
crate::error::InvalidParameterCombinationException {
message: self.message,
}
}
}
}
impl InvalidParameterCombinationException {
pub fn builder() -> crate::error::invalid_parameter_combination_exception::Builder {
crate::error::invalid_parameter_combination_exception::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct UpdateClusterError {
pub kind: UpdateClusterErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for UpdateClusterError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: UpdateClusterErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum UpdateClusterErrorKind {
ClusterNotFoundFault(crate::error::ClusterNotFoundFault),
InvalidClusterStateFault(crate::error::InvalidClusterStateFault),
InvalidParameterCombinationException(crate::error::InvalidParameterCombinationException),
InvalidParameterGroupStateFault(crate::error::InvalidParameterGroupStateFault),
InvalidParameterValueException(crate::error::InvalidParameterValueException),
ParameterGroupNotFoundFault(crate::error::ParameterGroupNotFoundFault),
ServiceLinkedRoleNotFoundFault(crate::error::ServiceLinkedRoleNotFoundFault),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for UpdateClusterError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
UpdateClusterErrorKind::ClusterNotFoundFault(_inner) => _inner.fmt(f),
UpdateClusterErrorKind::InvalidClusterStateFault(_inner) => _inner.fmt(f),
UpdateClusterErrorKind::InvalidParameterCombinationException(_inner) => _inner.fmt(f),
UpdateClusterErrorKind::InvalidParameterGroupStateFault(_inner) => _inner.fmt(f),
UpdateClusterErrorKind::InvalidParameterValueException(_inner) => _inner.fmt(f),
UpdateClusterErrorKind::ParameterGroupNotFoundFault(_inner) => _inner.fmt(f),
UpdateClusterErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => _inner.fmt(f),
UpdateClusterErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for UpdateClusterError {
fn code(&self) -> Option<&str> {
UpdateClusterError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl UpdateClusterError {
pub fn new(kind: UpdateClusterErrorKind, meta: aws_smithy_types::Error) -> Self {
Self { kind, meta }
}
pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
Self {
kind: UpdateClusterErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: UpdateClusterErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
}
}
pub fn message(&self) -> Option<&str> {
self.meta.message()
}
pub fn meta(&self) -> &aws_smithy_types::Error {
&self.meta
}
pub fn request_id(&self) -> Option<&str> {
self.meta.request_id()
}
pub fn code(&self) -> Option<&str> {
self.meta.code()
}
pub fn is_cluster_not_found_fault(&self) -> bool {
matches!(&self.kind, UpdateClusterErrorKind::ClusterNotFoundFault(_))
}
pub fn is_invalid_cluster_state_fault(&self) -> bool {
matches!(
&self.kind,
UpdateClusterErrorKind::InvalidClusterStateFault(_)
)
}
pub fn is_invalid_parameter_combination_exception(&self) -> bool {
matches!(
&self.kind,
UpdateClusterErrorKind::InvalidParameterCombinationException(_)
)
}
pub fn is_invalid_parameter_group_state_fault(&self) -> bool {
matches!(
&self.kind,
UpdateClusterErrorKind::InvalidParameterGroupStateFault(_)
)
}
pub fn is_invalid_parameter_value_exception(&self) -> bool {
matches!(
&self.kind,
UpdateClusterErrorKind::InvalidParameterValueException(_)
)
}
pub fn is_parameter_group_not_found_fault(&self) -> bool {
matches!(
&self.kind,
UpdateClusterErrorKind::ParameterGroupNotFoundFault(_)
)
}
pub fn is_service_linked_role_not_found_fault(&self) -> bool {
matches!(
&self.kind,
UpdateClusterErrorKind::ServiceLinkedRoleNotFoundFault(_)
)
}
}
impl std::error::Error for UpdateClusterError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
UpdateClusterErrorKind::ClusterNotFoundFault(_inner) => Some(_inner),
UpdateClusterErrorKind::InvalidClusterStateFault(_inner) => Some(_inner),
UpdateClusterErrorKind::InvalidParameterCombinationException(_inner) => Some(_inner),
UpdateClusterErrorKind::InvalidParameterGroupStateFault(_inner) => Some(_inner),
UpdateClusterErrorKind::InvalidParameterValueException(_inner) => Some(_inner),
UpdateClusterErrorKind::ParameterGroupNotFoundFault(_inner) => Some(_inner),
UpdateClusterErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => Some(_inner),
UpdateClusterErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct InvalidClusterStateFault {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl InvalidClusterStateFault {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for InvalidClusterStateFault {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "InvalidClusterStateFault")?;
if let Some(inner_10) = &self.message {
{
write!(f, ": {}", inner_10)?;
}
}
Ok(())
}
}
impl std::error::Error for InvalidClusterStateFault {}
pub mod invalid_cluster_state_fault {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::InvalidClusterStateFault {
crate::error::InvalidClusterStateFault {
message: self.message,
}
}
}
}
impl InvalidClusterStateFault {
pub fn builder() -> crate::error::invalid_cluster_state_fault::Builder {
crate::error::invalid_cluster_state_fault::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ClusterNotFoundFault {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl ClusterNotFoundFault {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for ClusterNotFoundFault {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "ClusterNotFoundFault")?;
if let Some(inner_11) = &self.message {
{
write!(f, ": {}", inner_11)?;
}
}
Ok(())
}
}
impl std::error::Error for ClusterNotFoundFault {}
pub mod cluster_not_found_fault {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::ClusterNotFoundFault {
crate::error::ClusterNotFoundFault {
message: self.message,
}
}
}
}
impl ClusterNotFoundFault {
pub fn builder() -> crate::error::cluster_not_found_fault::Builder {
crate::error::cluster_not_found_fault::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct UntagResourceError {
pub kind: UntagResourceErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for UntagResourceError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: UntagResourceErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum UntagResourceErrorKind {
ClusterNotFoundFault(crate::error::ClusterNotFoundFault),
InvalidArnFault(crate::error::InvalidArnFault),
InvalidClusterStateFault(crate::error::InvalidClusterStateFault),
InvalidParameterCombinationException(crate::error::InvalidParameterCombinationException),
InvalidParameterValueException(crate::error::InvalidParameterValueException),
ServiceLinkedRoleNotFoundFault(crate::error::ServiceLinkedRoleNotFoundFault),
TagNotFoundFault(crate::error::TagNotFoundFault),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for UntagResourceError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
UntagResourceErrorKind::ClusterNotFoundFault(_inner) => _inner.fmt(f),
UntagResourceErrorKind::InvalidArnFault(_inner) => _inner.fmt(f),
UntagResourceErrorKind::InvalidClusterStateFault(_inner) => _inner.fmt(f),
UntagResourceErrorKind::InvalidParameterCombinationException(_inner) => _inner.fmt(f),
UntagResourceErrorKind::InvalidParameterValueException(_inner) => _inner.fmt(f),
UntagResourceErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => _inner.fmt(f),
UntagResourceErrorKind::TagNotFoundFault(_inner) => _inner.fmt(f),
UntagResourceErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for UntagResourceError {
fn code(&self) -> Option<&str> {
UntagResourceError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl UntagResourceError {
pub fn new(kind: UntagResourceErrorKind, meta: aws_smithy_types::Error) -> Self {
Self { kind, meta }
}
pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
Self {
kind: UntagResourceErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: UntagResourceErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
}
}
pub fn message(&self) -> Option<&str> {
self.meta.message()
}
pub fn meta(&self) -> &aws_smithy_types::Error {
&self.meta
}
pub fn request_id(&self) -> Option<&str> {
self.meta.request_id()
}
pub fn code(&self) -> Option<&str> {
self.meta.code()
}
pub fn is_cluster_not_found_fault(&self) -> bool {
matches!(&self.kind, UntagResourceErrorKind::ClusterNotFoundFault(_))
}
pub fn is_invalid_arn_fault(&self) -> bool {
matches!(&self.kind, UntagResourceErrorKind::InvalidArnFault(_))
}
pub fn is_invalid_cluster_state_fault(&self) -> bool {
matches!(
&self.kind,
UntagResourceErrorKind::InvalidClusterStateFault(_)
)
}
pub fn is_invalid_parameter_combination_exception(&self) -> bool {
matches!(
&self.kind,
UntagResourceErrorKind::InvalidParameterCombinationException(_)
)
}
pub fn is_invalid_parameter_value_exception(&self) -> bool {
matches!(
&self.kind,
UntagResourceErrorKind::InvalidParameterValueException(_)
)
}
pub fn is_service_linked_role_not_found_fault(&self) -> bool {
matches!(
&self.kind,
UntagResourceErrorKind::ServiceLinkedRoleNotFoundFault(_)
)
}
pub fn is_tag_not_found_fault(&self) -> bool {
matches!(&self.kind, UntagResourceErrorKind::TagNotFoundFault(_))
}
}
impl std::error::Error for UntagResourceError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
UntagResourceErrorKind::ClusterNotFoundFault(_inner) => Some(_inner),
UntagResourceErrorKind::InvalidArnFault(_inner) => Some(_inner),
UntagResourceErrorKind::InvalidClusterStateFault(_inner) => Some(_inner),
UntagResourceErrorKind::InvalidParameterCombinationException(_inner) => Some(_inner),
UntagResourceErrorKind::InvalidParameterValueException(_inner) => Some(_inner),
UntagResourceErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => Some(_inner),
UntagResourceErrorKind::TagNotFoundFault(_inner) => Some(_inner),
UntagResourceErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct TagNotFoundFault {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl TagNotFoundFault {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for TagNotFoundFault {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "TagNotFoundFault")?;
if let Some(inner_12) = &self.message {
{
write!(f, ": {}", inner_12)?;
}
}
Ok(())
}
}
impl std::error::Error for TagNotFoundFault {}
pub mod tag_not_found_fault {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::TagNotFoundFault {
crate::error::TagNotFoundFault {
message: self.message,
}
}
}
}
impl TagNotFoundFault {
pub fn builder() -> crate::error::tag_not_found_fault::Builder {
crate::error::tag_not_found_fault::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct InvalidArnFault {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl InvalidArnFault {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for InvalidArnFault {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "InvalidArnFault [InvalidARNFault]")?;
if let Some(inner_13) = &self.message {
{
write!(f, ": {}", inner_13)?;
}
}
Ok(())
}
}
impl std::error::Error for InvalidArnFault {}
pub mod invalid_arn_fault {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::InvalidArnFault {
crate::error::InvalidArnFault {
message: self.message,
}
}
}
}
impl InvalidArnFault {
pub fn builder() -> crate::error::invalid_arn_fault::Builder {
crate::error::invalid_arn_fault::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct TagResourceError {
pub kind: TagResourceErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for TagResourceError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: TagResourceErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum TagResourceErrorKind {
ClusterNotFoundFault(crate::error::ClusterNotFoundFault),
InvalidArnFault(crate::error::InvalidArnFault),
InvalidClusterStateFault(crate::error::InvalidClusterStateFault),
InvalidParameterCombinationException(crate::error::InvalidParameterCombinationException),
InvalidParameterValueException(crate::error::InvalidParameterValueException),
ServiceLinkedRoleNotFoundFault(crate::error::ServiceLinkedRoleNotFoundFault),
TagQuotaPerResourceExceeded(crate::error::TagQuotaPerResourceExceeded),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for TagResourceError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
TagResourceErrorKind::ClusterNotFoundFault(_inner) => _inner.fmt(f),
TagResourceErrorKind::InvalidArnFault(_inner) => _inner.fmt(f),
TagResourceErrorKind::InvalidClusterStateFault(_inner) => _inner.fmt(f),
TagResourceErrorKind::InvalidParameterCombinationException(_inner) => _inner.fmt(f),
TagResourceErrorKind::InvalidParameterValueException(_inner) => _inner.fmt(f),
TagResourceErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => _inner.fmt(f),
TagResourceErrorKind::TagQuotaPerResourceExceeded(_inner) => _inner.fmt(f),
TagResourceErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for TagResourceError {
fn code(&self) -> Option<&str> {
TagResourceError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl TagResourceError {
pub fn new(kind: TagResourceErrorKind, meta: aws_smithy_types::Error) -> Self {
Self { kind, meta }
}
pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
Self {
kind: TagResourceErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: TagResourceErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
}
}
pub fn message(&self) -> Option<&str> {
self.meta.message()
}
pub fn meta(&self) -> &aws_smithy_types::Error {
&self.meta
}
pub fn request_id(&self) -> Option<&str> {
self.meta.request_id()
}
pub fn code(&self) -> Option<&str> {
self.meta.code()
}
pub fn is_cluster_not_found_fault(&self) -> bool {
matches!(&self.kind, TagResourceErrorKind::ClusterNotFoundFault(_))
}
pub fn is_invalid_arn_fault(&self) -> bool {
matches!(&self.kind, TagResourceErrorKind::InvalidArnFault(_))
}
pub fn is_invalid_cluster_state_fault(&self) -> bool {
matches!(
&self.kind,
TagResourceErrorKind::InvalidClusterStateFault(_)
)
}
pub fn is_invalid_parameter_combination_exception(&self) -> bool {
matches!(
&self.kind,
TagResourceErrorKind::InvalidParameterCombinationException(_)
)
}
pub fn is_invalid_parameter_value_exception(&self) -> bool {
matches!(
&self.kind,
TagResourceErrorKind::InvalidParameterValueException(_)
)
}
pub fn is_service_linked_role_not_found_fault(&self) -> bool {
matches!(
&self.kind,
TagResourceErrorKind::ServiceLinkedRoleNotFoundFault(_)
)
}
pub fn is_tag_quota_per_resource_exceeded(&self) -> bool {
matches!(
&self.kind,
TagResourceErrorKind::TagQuotaPerResourceExceeded(_)
)
}
}
impl std::error::Error for TagResourceError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
TagResourceErrorKind::ClusterNotFoundFault(_inner) => Some(_inner),
TagResourceErrorKind::InvalidArnFault(_inner) => Some(_inner),
TagResourceErrorKind::InvalidClusterStateFault(_inner) => Some(_inner),
TagResourceErrorKind::InvalidParameterCombinationException(_inner) => Some(_inner),
TagResourceErrorKind::InvalidParameterValueException(_inner) => Some(_inner),
TagResourceErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => Some(_inner),
TagResourceErrorKind::TagQuotaPerResourceExceeded(_inner) => Some(_inner),
TagResourceErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct TagQuotaPerResourceExceeded {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl TagQuotaPerResourceExceeded {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for TagQuotaPerResourceExceeded {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "TagQuotaPerResourceExceeded")?;
if let Some(inner_14) = &self.message {
{
write!(f, ": {}", inner_14)?;
}
}
Ok(())
}
}
impl std::error::Error for TagQuotaPerResourceExceeded {}
pub mod tag_quota_per_resource_exceeded {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::TagQuotaPerResourceExceeded {
crate::error::TagQuotaPerResourceExceeded {
message: self.message,
}
}
}
}
impl TagQuotaPerResourceExceeded {
pub fn builder() -> crate::error::tag_quota_per_resource_exceeded::Builder {
crate::error::tag_quota_per_resource_exceeded::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct RebootNodeError {
pub kind: RebootNodeErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for RebootNodeError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: RebootNodeErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum RebootNodeErrorKind {
ClusterNotFoundFault(crate::error::ClusterNotFoundFault),
InvalidClusterStateFault(crate::error::InvalidClusterStateFault),
InvalidParameterCombinationException(crate::error::InvalidParameterCombinationException),
InvalidParameterValueException(crate::error::InvalidParameterValueException),
NodeNotFoundFault(crate::error::NodeNotFoundFault),
ServiceLinkedRoleNotFoundFault(crate::error::ServiceLinkedRoleNotFoundFault),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for RebootNodeError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
RebootNodeErrorKind::ClusterNotFoundFault(_inner) => _inner.fmt(f),
RebootNodeErrorKind::InvalidClusterStateFault(_inner) => _inner.fmt(f),
RebootNodeErrorKind::InvalidParameterCombinationException(_inner) => _inner.fmt(f),
RebootNodeErrorKind::InvalidParameterValueException(_inner) => _inner.fmt(f),
RebootNodeErrorKind::NodeNotFoundFault(_inner) => _inner.fmt(f),
RebootNodeErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => _inner.fmt(f),
RebootNodeErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for RebootNodeError {
fn code(&self) -> Option<&str> {
RebootNodeError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl RebootNodeError {
pub fn new(kind: RebootNodeErrorKind, meta: aws_smithy_types::Error) -> Self {
Self { kind, meta }
}
pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
Self {
kind: RebootNodeErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: RebootNodeErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
}
}
pub fn message(&self) -> Option<&str> {
self.meta.message()
}
pub fn meta(&self) -> &aws_smithy_types::Error {
&self.meta
}
pub fn request_id(&self) -> Option<&str> {
self.meta.request_id()
}
pub fn code(&self) -> Option<&str> {
self.meta.code()
}
pub fn is_cluster_not_found_fault(&self) -> bool {
matches!(&self.kind, RebootNodeErrorKind::ClusterNotFoundFault(_))
}
pub fn is_invalid_cluster_state_fault(&self) -> bool {
matches!(&self.kind, RebootNodeErrorKind::InvalidClusterStateFault(_))
}
pub fn is_invalid_parameter_combination_exception(&self) -> bool {
matches!(
&self.kind,
RebootNodeErrorKind::InvalidParameterCombinationException(_)
)
}
pub fn is_invalid_parameter_value_exception(&self) -> bool {
matches!(
&self.kind,
RebootNodeErrorKind::InvalidParameterValueException(_)
)
}
pub fn is_node_not_found_fault(&self) -> bool {
matches!(&self.kind, RebootNodeErrorKind::NodeNotFoundFault(_))
}
pub fn is_service_linked_role_not_found_fault(&self) -> bool {
matches!(
&self.kind,
RebootNodeErrorKind::ServiceLinkedRoleNotFoundFault(_)
)
}
}
impl std::error::Error for RebootNodeError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
RebootNodeErrorKind::ClusterNotFoundFault(_inner) => Some(_inner),
RebootNodeErrorKind::InvalidClusterStateFault(_inner) => Some(_inner),
RebootNodeErrorKind::InvalidParameterCombinationException(_inner) => Some(_inner),
RebootNodeErrorKind::InvalidParameterValueException(_inner) => Some(_inner),
RebootNodeErrorKind::NodeNotFoundFault(_inner) => Some(_inner),
RebootNodeErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => Some(_inner),
RebootNodeErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct NodeNotFoundFault {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl NodeNotFoundFault {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for NodeNotFoundFault {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "NodeNotFoundFault")?;
if let Some(inner_15) = &self.message {
{
write!(f, ": {}", inner_15)?;
}
}
Ok(())
}
}
impl std::error::Error for NodeNotFoundFault {}
pub mod node_not_found_fault {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::NodeNotFoundFault {
crate::error::NodeNotFoundFault {
message: self.message,
}
}
}
}
impl NodeNotFoundFault {
pub fn builder() -> crate::error::node_not_found_fault::Builder {
crate::error::node_not_found_fault::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListTagsError {
pub kind: ListTagsErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for ListTagsError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: ListTagsErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListTagsErrorKind {
ClusterNotFoundFault(crate::error::ClusterNotFoundFault),
InvalidArnFault(crate::error::InvalidArnFault),
InvalidClusterStateFault(crate::error::InvalidClusterStateFault),
InvalidParameterCombinationException(crate::error::InvalidParameterCombinationException),
InvalidParameterValueException(crate::error::InvalidParameterValueException),
ServiceLinkedRoleNotFoundFault(crate::error::ServiceLinkedRoleNotFoundFault),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for ListTagsError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
ListTagsErrorKind::ClusterNotFoundFault(_inner) => _inner.fmt(f),
ListTagsErrorKind::InvalidArnFault(_inner) => _inner.fmt(f),
ListTagsErrorKind::InvalidClusterStateFault(_inner) => _inner.fmt(f),
ListTagsErrorKind::InvalidParameterCombinationException(_inner) => _inner.fmt(f),
ListTagsErrorKind::InvalidParameterValueException(_inner) => _inner.fmt(f),
ListTagsErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => _inner.fmt(f),
ListTagsErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for ListTagsError {
fn code(&self) -> Option<&str> {
ListTagsError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl ListTagsError {
pub fn new(kind: ListTagsErrorKind, meta: aws_smithy_types::Error) -> Self {
Self { kind, meta }
}
pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
Self {
kind: ListTagsErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: ListTagsErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
}
}
pub fn message(&self) -> Option<&str> {
self.meta.message()
}
pub fn meta(&self) -> &aws_smithy_types::Error {
&self.meta
}
pub fn request_id(&self) -> Option<&str> {
self.meta.request_id()
}
pub fn code(&self) -> Option<&str> {
self.meta.code()
}
pub fn is_cluster_not_found_fault(&self) -> bool {
matches!(&self.kind, ListTagsErrorKind::ClusterNotFoundFault(_))
}
pub fn is_invalid_arn_fault(&self) -> bool {
matches!(&self.kind, ListTagsErrorKind::InvalidArnFault(_))
}
pub fn is_invalid_cluster_state_fault(&self) -> bool {
matches!(&self.kind, ListTagsErrorKind::InvalidClusterStateFault(_))
}
pub fn is_invalid_parameter_combination_exception(&self) -> bool {
matches!(
&self.kind,
ListTagsErrorKind::InvalidParameterCombinationException(_)
)
}
pub fn is_invalid_parameter_value_exception(&self) -> bool {
matches!(
&self.kind,
ListTagsErrorKind::InvalidParameterValueException(_)
)
}
pub fn is_service_linked_role_not_found_fault(&self) -> bool {
matches!(
&self.kind,
ListTagsErrorKind::ServiceLinkedRoleNotFoundFault(_)
)
}
}
impl std::error::Error for ListTagsError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
ListTagsErrorKind::ClusterNotFoundFault(_inner) => Some(_inner),
ListTagsErrorKind::InvalidArnFault(_inner) => Some(_inner),
ListTagsErrorKind::InvalidClusterStateFault(_inner) => Some(_inner),
ListTagsErrorKind::InvalidParameterCombinationException(_inner) => Some(_inner),
ListTagsErrorKind::InvalidParameterValueException(_inner) => Some(_inner),
ListTagsErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => Some(_inner),
ListTagsErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct IncreaseReplicationFactorError {
pub kind: IncreaseReplicationFactorErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for IncreaseReplicationFactorError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: IncreaseReplicationFactorErrorKind::Unhandled(crate::error::Unhandled::new(
source,
)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum IncreaseReplicationFactorErrorKind {
ClusterNotFoundFault(crate::error::ClusterNotFoundFault),
InsufficientClusterCapacityFault(crate::error::InsufficientClusterCapacityFault),
InvalidClusterStateFault(crate::error::InvalidClusterStateFault),
InvalidParameterCombinationException(crate::error::InvalidParameterCombinationException),
InvalidParameterValueException(crate::error::InvalidParameterValueException),
InvalidVpcNetworkStateFault(crate::error::InvalidVpcNetworkStateFault),
NodeQuotaForClusterExceededFault(crate::error::NodeQuotaForClusterExceededFault),
NodeQuotaForCustomerExceededFault(crate::error::NodeQuotaForCustomerExceededFault),
ServiceLinkedRoleNotFoundFault(crate::error::ServiceLinkedRoleNotFoundFault),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for IncreaseReplicationFactorError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
IncreaseReplicationFactorErrorKind::ClusterNotFoundFault(_inner) => _inner.fmt(f),
IncreaseReplicationFactorErrorKind::InsufficientClusterCapacityFault(_inner) => {
_inner.fmt(f)
}
IncreaseReplicationFactorErrorKind::InvalidClusterStateFault(_inner) => _inner.fmt(f),
IncreaseReplicationFactorErrorKind::InvalidParameterCombinationException(_inner) => {
_inner.fmt(f)
}
IncreaseReplicationFactorErrorKind::InvalidParameterValueException(_inner) => {
_inner.fmt(f)
}
IncreaseReplicationFactorErrorKind::InvalidVpcNetworkStateFault(_inner) => {
_inner.fmt(f)
}
IncreaseReplicationFactorErrorKind::NodeQuotaForClusterExceededFault(_inner) => {
_inner.fmt(f)
}
IncreaseReplicationFactorErrorKind::NodeQuotaForCustomerExceededFault(_inner) => {
_inner.fmt(f)
}
IncreaseReplicationFactorErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => {
_inner.fmt(f)
}
IncreaseReplicationFactorErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for IncreaseReplicationFactorError {
fn code(&self) -> Option<&str> {
IncreaseReplicationFactorError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl IncreaseReplicationFactorError {
pub fn new(kind: IncreaseReplicationFactorErrorKind, meta: aws_smithy_types::Error) -> Self {
Self { kind, meta }
}
pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
Self {
kind: IncreaseReplicationFactorErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: IncreaseReplicationFactorErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
}
}
pub fn message(&self) -> Option<&str> {
self.meta.message()
}
pub fn meta(&self) -> &aws_smithy_types::Error {
&self.meta
}
pub fn request_id(&self) -> Option<&str> {
self.meta.request_id()
}
pub fn code(&self) -> Option<&str> {
self.meta.code()
}
pub fn is_cluster_not_found_fault(&self) -> bool {
matches!(
&self.kind,
IncreaseReplicationFactorErrorKind::ClusterNotFoundFault(_)
)
}
pub fn is_insufficient_cluster_capacity_fault(&self) -> bool {
matches!(
&self.kind,
IncreaseReplicationFactorErrorKind::InsufficientClusterCapacityFault(_)
)
}
pub fn is_invalid_cluster_state_fault(&self) -> bool {
matches!(
&self.kind,
IncreaseReplicationFactorErrorKind::InvalidClusterStateFault(_)
)
}
pub fn is_invalid_parameter_combination_exception(&self) -> bool {
matches!(
&self.kind,
IncreaseReplicationFactorErrorKind::InvalidParameterCombinationException(_)
)
}
pub fn is_invalid_parameter_value_exception(&self) -> bool {
matches!(
&self.kind,
IncreaseReplicationFactorErrorKind::InvalidParameterValueException(_)
)
}
pub fn is_invalid_vpc_network_state_fault(&self) -> bool {
matches!(
&self.kind,
IncreaseReplicationFactorErrorKind::InvalidVpcNetworkStateFault(_)
)
}
pub fn is_node_quota_for_cluster_exceeded_fault(&self) -> bool {
matches!(
&self.kind,
IncreaseReplicationFactorErrorKind::NodeQuotaForClusterExceededFault(_)
)
}
pub fn is_node_quota_for_customer_exceeded_fault(&self) -> bool {
matches!(
&self.kind,
IncreaseReplicationFactorErrorKind::NodeQuotaForCustomerExceededFault(_)
)
}
pub fn is_service_linked_role_not_found_fault(&self) -> bool {
matches!(
&self.kind,
IncreaseReplicationFactorErrorKind::ServiceLinkedRoleNotFoundFault(_)
)
}
}
impl std::error::Error for IncreaseReplicationFactorError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
IncreaseReplicationFactorErrorKind::ClusterNotFoundFault(_inner) => Some(_inner),
IncreaseReplicationFactorErrorKind::InsufficientClusterCapacityFault(_inner) => {
Some(_inner)
}
IncreaseReplicationFactorErrorKind::InvalidClusterStateFault(_inner) => Some(_inner),
IncreaseReplicationFactorErrorKind::InvalidParameterCombinationException(_inner) => {
Some(_inner)
}
IncreaseReplicationFactorErrorKind::InvalidParameterValueException(_inner) => {
Some(_inner)
}
IncreaseReplicationFactorErrorKind::InvalidVpcNetworkStateFault(_inner) => Some(_inner),
IncreaseReplicationFactorErrorKind::NodeQuotaForClusterExceededFault(_inner) => {
Some(_inner)
}
IncreaseReplicationFactorErrorKind::NodeQuotaForCustomerExceededFault(_inner) => {
Some(_inner)
}
IncreaseReplicationFactorErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => {
Some(_inner)
}
IncreaseReplicationFactorErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct NodeQuotaForCustomerExceededFault {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl NodeQuotaForCustomerExceededFault {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for NodeQuotaForCustomerExceededFault {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "NodeQuotaForCustomerExceededFault")?;
if let Some(inner_16) = &self.message {
{
write!(f, ": {}", inner_16)?;
}
}
Ok(())
}
}
impl std::error::Error for NodeQuotaForCustomerExceededFault {}
pub mod node_quota_for_customer_exceeded_fault {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::NodeQuotaForCustomerExceededFault {
crate::error::NodeQuotaForCustomerExceededFault {
message: self.message,
}
}
}
}
impl NodeQuotaForCustomerExceededFault {
pub fn builder() -> crate::error::node_quota_for_customer_exceeded_fault::Builder {
crate::error::node_quota_for_customer_exceeded_fault::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct NodeQuotaForClusterExceededFault {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl NodeQuotaForClusterExceededFault {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for NodeQuotaForClusterExceededFault {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "NodeQuotaForClusterExceededFault")?;
if let Some(inner_17) = &self.message {
{
write!(f, ": {}", inner_17)?;
}
}
Ok(())
}
}
impl std::error::Error for NodeQuotaForClusterExceededFault {}
pub mod node_quota_for_cluster_exceeded_fault {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::NodeQuotaForClusterExceededFault {
crate::error::NodeQuotaForClusterExceededFault {
message: self.message,
}
}
}
}
impl NodeQuotaForClusterExceededFault {
pub fn builder() -> crate::error::node_quota_for_cluster_exceeded_fault::Builder {
crate::error::node_quota_for_cluster_exceeded_fault::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct InvalidVpcNetworkStateFault {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl InvalidVpcNetworkStateFault {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for InvalidVpcNetworkStateFault {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
"InvalidVpcNetworkStateFault [InvalidVPCNetworkStateFault]"
)?;
if let Some(inner_18) = &self.message {
{
write!(f, ": {}", inner_18)?;
}
}
Ok(())
}
}
impl std::error::Error for InvalidVpcNetworkStateFault {}
pub mod invalid_vpc_network_state_fault {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::InvalidVpcNetworkStateFault {
crate::error::InvalidVpcNetworkStateFault {
message: self.message,
}
}
}
}
impl InvalidVpcNetworkStateFault {
pub fn builder() -> crate::error::invalid_vpc_network_state_fault::Builder {
crate::error::invalid_vpc_network_state_fault::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct InsufficientClusterCapacityFault {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl InsufficientClusterCapacityFault {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for InsufficientClusterCapacityFault {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "InsufficientClusterCapacityFault")?;
if let Some(inner_19) = &self.message {
{
write!(f, ": {}", inner_19)?;
}
}
Ok(())
}
}
impl std::error::Error for InsufficientClusterCapacityFault {}
pub mod insufficient_cluster_capacity_fault {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::InsufficientClusterCapacityFault {
crate::error::InsufficientClusterCapacityFault {
message: self.message,
}
}
}
}
impl InsufficientClusterCapacityFault {
pub fn builder() -> crate::error::insufficient_cluster_capacity_fault::Builder {
crate::error::insufficient_cluster_capacity_fault::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DescribeSubnetGroupsError {
pub kind: DescribeSubnetGroupsErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for DescribeSubnetGroupsError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: DescribeSubnetGroupsErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DescribeSubnetGroupsErrorKind {
ServiceLinkedRoleNotFoundFault(crate::error::ServiceLinkedRoleNotFoundFault),
SubnetGroupNotFoundFault(crate::error::SubnetGroupNotFoundFault),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for DescribeSubnetGroupsError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
DescribeSubnetGroupsErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => _inner.fmt(f),
DescribeSubnetGroupsErrorKind::SubnetGroupNotFoundFault(_inner) => _inner.fmt(f),
DescribeSubnetGroupsErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for DescribeSubnetGroupsError {
fn code(&self) -> Option<&str> {
DescribeSubnetGroupsError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl DescribeSubnetGroupsError {
pub fn new(kind: DescribeSubnetGroupsErrorKind, meta: aws_smithy_types::Error) -> Self {
Self { kind, meta }
}
pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
Self {
kind: DescribeSubnetGroupsErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: DescribeSubnetGroupsErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
}
}
pub fn message(&self) -> Option<&str> {
self.meta.message()
}
pub fn meta(&self) -> &aws_smithy_types::Error {
&self.meta
}
pub fn request_id(&self) -> Option<&str> {
self.meta.request_id()
}
pub fn code(&self) -> Option<&str> {
self.meta.code()
}
pub fn is_service_linked_role_not_found_fault(&self) -> bool {
matches!(
&self.kind,
DescribeSubnetGroupsErrorKind::ServiceLinkedRoleNotFoundFault(_)
)
}
pub fn is_subnet_group_not_found_fault(&self) -> bool {
matches!(
&self.kind,
DescribeSubnetGroupsErrorKind::SubnetGroupNotFoundFault(_)
)
}
}
impl std::error::Error for DescribeSubnetGroupsError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
DescribeSubnetGroupsErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => Some(_inner),
DescribeSubnetGroupsErrorKind::SubnetGroupNotFoundFault(_inner) => Some(_inner),
DescribeSubnetGroupsErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DescribeParametersError {
pub kind: DescribeParametersErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for DescribeParametersError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: DescribeParametersErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DescribeParametersErrorKind {
InvalidParameterCombinationException(crate::error::InvalidParameterCombinationException),
InvalidParameterValueException(crate::error::InvalidParameterValueException),
ParameterGroupNotFoundFault(crate::error::ParameterGroupNotFoundFault),
ServiceLinkedRoleNotFoundFault(crate::error::ServiceLinkedRoleNotFoundFault),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for DescribeParametersError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
DescribeParametersErrorKind::InvalidParameterCombinationException(_inner) => {
_inner.fmt(f)
}
DescribeParametersErrorKind::InvalidParameterValueException(_inner) => _inner.fmt(f),
DescribeParametersErrorKind::ParameterGroupNotFoundFault(_inner) => _inner.fmt(f),
DescribeParametersErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => _inner.fmt(f),
DescribeParametersErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for DescribeParametersError {
fn code(&self) -> Option<&str> {
DescribeParametersError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl DescribeParametersError {
pub fn new(kind: DescribeParametersErrorKind, meta: aws_smithy_types::Error) -> Self {
Self { kind, meta }
}
pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
Self {
kind: DescribeParametersErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: DescribeParametersErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
}
}
pub fn message(&self) -> Option<&str> {
self.meta.message()
}
pub fn meta(&self) -> &aws_smithy_types::Error {
&self.meta
}
pub fn request_id(&self) -> Option<&str> {
self.meta.request_id()
}
pub fn code(&self) -> Option<&str> {
self.meta.code()
}
pub fn is_invalid_parameter_combination_exception(&self) -> bool {
matches!(
&self.kind,
DescribeParametersErrorKind::InvalidParameterCombinationException(_)
)
}
pub fn is_invalid_parameter_value_exception(&self) -> bool {
matches!(
&self.kind,
DescribeParametersErrorKind::InvalidParameterValueException(_)
)
}
pub fn is_parameter_group_not_found_fault(&self) -> bool {
matches!(
&self.kind,
DescribeParametersErrorKind::ParameterGroupNotFoundFault(_)
)
}
pub fn is_service_linked_role_not_found_fault(&self) -> bool {
matches!(
&self.kind,
DescribeParametersErrorKind::ServiceLinkedRoleNotFoundFault(_)
)
}
}
impl std::error::Error for DescribeParametersError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
DescribeParametersErrorKind::InvalidParameterCombinationException(_inner) => {
Some(_inner)
}
DescribeParametersErrorKind::InvalidParameterValueException(_inner) => Some(_inner),
DescribeParametersErrorKind::ParameterGroupNotFoundFault(_inner) => Some(_inner),
DescribeParametersErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => Some(_inner),
DescribeParametersErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DescribeParameterGroupsError {
pub kind: DescribeParameterGroupsErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for DescribeParameterGroupsError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: DescribeParameterGroupsErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DescribeParameterGroupsErrorKind {
InvalidParameterCombinationException(crate::error::InvalidParameterCombinationException),
InvalidParameterValueException(crate::error::InvalidParameterValueException),
ParameterGroupNotFoundFault(crate::error::ParameterGroupNotFoundFault),
ServiceLinkedRoleNotFoundFault(crate::error::ServiceLinkedRoleNotFoundFault),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for DescribeParameterGroupsError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
DescribeParameterGroupsErrorKind::InvalidParameterCombinationException(_inner) => {
_inner.fmt(f)
}
DescribeParameterGroupsErrorKind::InvalidParameterValueException(_inner) => {
_inner.fmt(f)
}
DescribeParameterGroupsErrorKind::ParameterGroupNotFoundFault(_inner) => _inner.fmt(f),
DescribeParameterGroupsErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => {
_inner.fmt(f)
}
DescribeParameterGroupsErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for DescribeParameterGroupsError {
fn code(&self) -> Option<&str> {
DescribeParameterGroupsError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl DescribeParameterGroupsError {
pub fn new(kind: DescribeParameterGroupsErrorKind, meta: aws_smithy_types::Error) -> Self {
Self { kind, meta }
}
pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
Self {
kind: DescribeParameterGroupsErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: DescribeParameterGroupsErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
}
}
pub fn message(&self) -> Option<&str> {
self.meta.message()
}
pub fn meta(&self) -> &aws_smithy_types::Error {
&self.meta
}
pub fn request_id(&self) -> Option<&str> {
self.meta.request_id()
}
pub fn code(&self) -> Option<&str> {
self.meta.code()
}
pub fn is_invalid_parameter_combination_exception(&self) -> bool {
matches!(
&self.kind,
DescribeParameterGroupsErrorKind::InvalidParameterCombinationException(_)
)
}
pub fn is_invalid_parameter_value_exception(&self) -> bool {
matches!(
&self.kind,
DescribeParameterGroupsErrorKind::InvalidParameterValueException(_)
)
}
pub fn is_parameter_group_not_found_fault(&self) -> bool {
matches!(
&self.kind,
DescribeParameterGroupsErrorKind::ParameterGroupNotFoundFault(_)
)
}
pub fn is_service_linked_role_not_found_fault(&self) -> bool {
matches!(
&self.kind,
DescribeParameterGroupsErrorKind::ServiceLinkedRoleNotFoundFault(_)
)
}
}
impl std::error::Error for DescribeParameterGroupsError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
DescribeParameterGroupsErrorKind::InvalidParameterCombinationException(_inner) => {
Some(_inner)
}
DescribeParameterGroupsErrorKind::InvalidParameterValueException(_inner) => {
Some(_inner)
}
DescribeParameterGroupsErrorKind::ParameterGroupNotFoundFault(_inner) => Some(_inner),
DescribeParameterGroupsErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => {
Some(_inner)
}
DescribeParameterGroupsErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DescribeEventsError {
pub kind: DescribeEventsErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for DescribeEventsError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: DescribeEventsErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DescribeEventsErrorKind {
InvalidParameterCombinationException(crate::error::InvalidParameterCombinationException),
InvalidParameterValueException(crate::error::InvalidParameterValueException),
ServiceLinkedRoleNotFoundFault(crate::error::ServiceLinkedRoleNotFoundFault),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for DescribeEventsError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
DescribeEventsErrorKind::InvalidParameterCombinationException(_inner) => _inner.fmt(f),
DescribeEventsErrorKind::InvalidParameterValueException(_inner) => _inner.fmt(f),
DescribeEventsErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => _inner.fmt(f),
DescribeEventsErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for DescribeEventsError {
fn code(&self) -> Option<&str> {
DescribeEventsError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl DescribeEventsError {
pub fn new(kind: DescribeEventsErrorKind, meta: aws_smithy_types::Error) -> Self {
Self { kind, meta }
}
pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
Self {
kind: DescribeEventsErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: DescribeEventsErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
}
}
pub fn message(&self) -> Option<&str> {
self.meta.message()
}
pub fn meta(&self) -> &aws_smithy_types::Error {
&self.meta
}
pub fn request_id(&self) -> Option<&str> {
self.meta.request_id()
}
pub fn code(&self) -> Option<&str> {
self.meta.code()
}
pub fn is_invalid_parameter_combination_exception(&self) -> bool {
matches!(
&self.kind,
DescribeEventsErrorKind::InvalidParameterCombinationException(_)
)
}
pub fn is_invalid_parameter_value_exception(&self) -> bool {
matches!(
&self.kind,
DescribeEventsErrorKind::InvalidParameterValueException(_)
)
}
pub fn is_service_linked_role_not_found_fault(&self) -> bool {
matches!(
&self.kind,
DescribeEventsErrorKind::ServiceLinkedRoleNotFoundFault(_)
)
}
}
impl std::error::Error for DescribeEventsError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
DescribeEventsErrorKind::InvalidParameterCombinationException(_inner) => Some(_inner),
DescribeEventsErrorKind::InvalidParameterValueException(_inner) => Some(_inner),
DescribeEventsErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => Some(_inner),
DescribeEventsErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DescribeDefaultParametersError {
pub kind: DescribeDefaultParametersErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for DescribeDefaultParametersError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: DescribeDefaultParametersErrorKind::Unhandled(crate::error::Unhandled::new(
source,
)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DescribeDefaultParametersErrorKind {
InvalidParameterCombinationException(crate::error::InvalidParameterCombinationException),
InvalidParameterValueException(crate::error::InvalidParameterValueException),
ServiceLinkedRoleNotFoundFault(crate::error::ServiceLinkedRoleNotFoundFault),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for DescribeDefaultParametersError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
DescribeDefaultParametersErrorKind::InvalidParameterCombinationException(_inner) => {
_inner.fmt(f)
}
DescribeDefaultParametersErrorKind::InvalidParameterValueException(_inner) => {
_inner.fmt(f)
}
DescribeDefaultParametersErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => {
_inner.fmt(f)
}
DescribeDefaultParametersErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for DescribeDefaultParametersError {
fn code(&self) -> Option<&str> {
DescribeDefaultParametersError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl DescribeDefaultParametersError {
pub fn new(kind: DescribeDefaultParametersErrorKind, meta: aws_smithy_types::Error) -> Self {
Self { kind, meta }
}
pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
Self {
kind: DescribeDefaultParametersErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: DescribeDefaultParametersErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
}
}
pub fn message(&self) -> Option<&str> {
self.meta.message()
}
pub fn meta(&self) -> &aws_smithy_types::Error {
&self.meta
}
pub fn request_id(&self) -> Option<&str> {
self.meta.request_id()
}
pub fn code(&self) -> Option<&str> {
self.meta.code()
}
pub fn is_invalid_parameter_combination_exception(&self) -> bool {
matches!(
&self.kind,
DescribeDefaultParametersErrorKind::InvalidParameterCombinationException(_)
)
}
pub fn is_invalid_parameter_value_exception(&self) -> bool {
matches!(
&self.kind,
DescribeDefaultParametersErrorKind::InvalidParameterValueException(_)
)
}
pub fn is_service_linked_role_not_found_fault(&self) -> bool {
matches!(
&self.kind,
DescribeDefaultParametersErrorKind::ServiceLinkedRoleNotFoundFault(_)
)
}
}
impl std::error::Error for DescribeDefaultParametersError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
DescribeDefaultParametersErrorKind::InvalidParameterCombinationException(_inner) => {
Some(_inner)
}
DescribeDefaultParametersErrorKind::InvalidParameterValueException(_inner) => {
Some(_inner)
}
DescribeDefaultParametersErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => {
Some(_inner)
}
DescribeDefaultParametersErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DescribeClustersError {
pub kind: DescribeClustersErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for DescribeClustersError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: DescribeClustersErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DescribeClustersErrorKind {
ClusterNotFoundFault(crate::error::ClusterNotFoundFault),
InvalidParameterCombinationException(crate::error::InvalidParameterCombinationException),
InvalidParameterValueException(crate::error::InvalidParameterValueException),
ServiceLinkedRoleNotFoundFault(crate::error::ServiceLinkedRoleNotFoundFault),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for DescribeClustersError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
DescribeClustersErrorKind::ClusterNotFoundFault(_inner) => _inner.fmt(f),
DescribeClustersErrorKind::InvalidParameterCombinationException(_inner) => {
_inner.fmt(f)
}
DescribeClustersErrorKind::InvalidParameterValueException(_inner) => _inner.fmt(f),
DescribeClustersErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => _inner.fmt(f),
DescribeClustersErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for DescribeClustersError {
fn code(&self) -> Option<&str> {
DescribeClustersError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl DescribeClustersError {
pub fn new(kind: DescribeClustersErrorKind, meta: aws_smithy_types::Error) -> Self {
Self { kind, meta }
}
pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
Self {
kind: DescribeClustersErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: DescribeClustersErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
}
}
pub fn message(&self) -> Option<&str> {
self.meta.message()
}
pub fn meta(&self) -> &aws_smithy_types::Error {
&self.meta
}
pub fn request_id(&self) -> Option<&str> {
self.meta.request_id()
}
pub fn code(&self) -> Option<&str> {
self.meta.code()
}
pub fn is_cluster_not_found_fault(&self) -> bool {
matches!(
&self.kind,
DescribeClustersErrorKind::ClusterNotFoundFault(_)
)
}
pub fn is_invalid_parameter_combination_exception(&self) -> bool {
matches!(
&self.kind,
DescribeClustersErrorKind::InvalidParameterCombinationException(_)
)
}
pub fn is_invalid_parameter_value_exception(&self) -> bool {
matches!(
&self.kind,
DescribeClustersErrorKind::InvalidParameterValueException(_)
)
}
pub fn is_service_linked_role_not_found_fault(&self) -> bool {
matches!(
&self.kind,
DescribeClustersErrorKind::ServiceLinkedRoleNotFoundFault(_)
)
}
}
impl std::error::Error for DescribeClustersError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
DescribeClustersErrorKind::ClusterNotFoundFault(_inner) => Some(_inner),
DescribeClustersErrorKind::InvalidParameterCombinationException(_inner) => Some(_inner),
DescribeClustersErrorKind::InvalidParameterValueException(_inner) => Some(_inner),
DescribeClustersErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => Some(_inner),
DescribeClustersErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DeleteSubnetGroupError {
pub kind: DeleteSubnetGroupErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for DeleteSubnetGroupError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: DeleteSubnetGroupErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DeleteSubnetGroupErrorKind {
ServiceLinkedRoleNotFoundFault(crate::error::ServiceLinkedRoleNotFoundFault),
SubnetGroupInUseFault(crate::error::SubnetGroupInUseFault),
SubnetGroupNotFoundFault(crate::error::SubnetGroupNotFoundFault),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for DeleteSubnetGroupError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
DeleteSubnetGroupErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => _inner.fmt(f),
DeleteSubnetGroupErrorKind::SubnetGroupInUseFault(_inner) => _inner.fmt(f),
DeleteSubnetGroupErrorKind::SubnetGroupNotFoundFault(_inner) => _inner.fmt(f),
DeleteSubnetGroupErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for DeleteSubnetGroupError {
fn code(&self) -> Option<&str> {
DeleteSubnetGroupError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl DeleteSubnetGroupError {
pub fn new(kind: DeleteSubnetGroupErrorKind, meta: aws_smithy_types::Error) -> Self {
Self { kind, meta }
}
pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
Self {
kind: DeleteSubnetGroupErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: DeleteSubnetGroupErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
}
}
pub fn message(&self) -> Option<&str> {
self.meta.message()
}
pub fn meta(&self) -> &aws_smithy_types::Error {
&self.meta
}
pub fn request_id(&self) -> Option<&str> {
self.meta.request_id()
}
pub fn code(&self) -> Option<&str> {
self.meta.code()
}
pub fn is_service_linked_role_not_found_fault(&self) -> bool {
matches!(
&self.kind,
DeleteSubnetGroupErrorKind::ServiceLinkedRoleNotFoundFault(_)
)
}
pub fn is_subnet_group_in_use_fault(&self) -> bool {
matches!(
&self.kind,
DeleteSubnetGroupErrorKind::SubnetGroupInUseFault(_)
)
}
pub fn is_subnet_group_not_found_fault(&self) -> bool {
matches!(
&self.kind,
DeleteSubnetGroupErrorKind::SubnetGroupNotFoundFault(_)
)
}
}
impl std::error::Error for DeleteSubnetGroupError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
DeleteSubnetGroupErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => Some(_inner),
DeleteSubnetGroupErrorKind::SubnetGroupInUseFault(_inner) => Some(_inner),
DeleteSubnetGroupErrorKind::SubnetGroupNotFoundFault(_inner) => Some(_inner),
DeleteSubnetGroupErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct SubnetGroupInUseFault {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl SubnetGroupInUseFault {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for SubnetGroupInUseFault {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "SubnetGroupInUseFault")?;
if let Some(inner_20) = &self.message {
{
write!(f, ": {}", inner_20)?;
}
}
Ok(())
}
}
impl std::error::Error for SubnetGroupInUseFault {}
pub mod subnet_group_in_use_fault {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::SubnetGroupInUseFault {
crate::error::SubnetGroupInUseFault {
message: self.message,
}
}
}
}
impl SubnetGroupInUseFault {
pub fn builder() -> crate::error::subnet_group_in_use_fault::Builder {
crate::error::subnet_group_in_use_fault::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DeleteParameterGroupError {
pub kind: DeleteParameterGroupErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for DeleteParameterGroupError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: DeleteParameterGroupErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DeleteParameterGroupErrorKind {
InvalidParameterCombinationException(crate::error::InvalidParameterCombinationException),
InvalidParameterGroupStateFault(crate::error::InvalidParameterGroupStateFault),
InvalidParameterValueException(crate::error::InvalidParameterValueException),
ParameterGroupNotFoundFault(crate::error::ParameterGroupNotFoundFault),
ServiceLinkedRoleNotFoundFault(crate::error::ServiceLinkedRoleNotFoundFault),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for DeleteParameterGroupError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
DeleteParameterGroupErrorKind::InvalidParameterCombinationException(_inner) => {
_inner.fmt(f)
}
DeleteParameterGroupErrorKind::InvalidParameterGroupStateFault(_inner) => _inner.fmt(f),
DeleteParameterGroupErrorKind::InvalidParameterValueException(_inner) => _inner.fmt(f),
DeleteParameterGroupErrorKind::ParameterGroupNotFoundFault(_inner) => _inner.fmt(f),
DeleteParameterGroupErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => _inner.fmt(f),
DeleteParameterGroupErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for DeleteParameterGroupError {
fn code(&self) -> Option<&str> {
DeleteParameterGroupError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl DeleteParameterGroupError {
pub fn new(kind: DeleteParameterGroupErrorKind, meta: aws_smithy_types::Error) -> Self {
Self { kind, meta }
}
pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
Self {
kind: DeleteParameterGroupErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: DeleteParameterGroupErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
}
}
pub fn message(&self) -> Option<&str> {
self.meta.message()
}
pub fn meta(&self) -> &aws_smithy_types::Error {
&self.meta
}
pub fn request_id(&self) -> Option<&str> {
self.meta.request_id()
}
pub fn code(&self) -> Option<&str> {
self.meta.code()
}
pub fn is_invalid_parameter_combination_exception(&self) -> bool {
matches!(
&self.kind,
DeleteParameterGroupErrorKind::InvalidParameterCombinationException(_)
)
}
pub fn is_invalid_parameter_group_state_fault(&self) -> bool {
matches!(
&self.kind,
DeleteParameterGroupErrorKind::InvalidParameterGroupStateFault(_)
)
}
pub fn is_invalid_parameter_value_exception(&self) -> bool {
matches!(
&self.kind,
DeleteParameterGroupErrorKind::InvalidParameterValueException(_)
)
}
pub fn is_parameter_group_not_found_fault(&self) -> bool {
matches!(
&self.kind,
DeleteParameterGroupErrorKind::ParameterGroupNotFoundFault(_)
)
}
pub fn is_service_linked_role_not_found_fault(&self) -> bool {
matches!(
&self.kind,
DeleteParameterGroupErrorKind::ServiceLinkedRoleNotFoundFault(_)
)
}
}
impl std::error::Error for DeleteParameterGroupError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
DeleteParameterGroupErrorKind::InvalidParameterCombinationException(_inner) => {
Some(_inner)
}
DeleteParameterGroupErrorKind::InvalidParameterGroupStateFault(_inner) => Some(_inner),
DeleteParameterGroupErrorKind::InvalidParameterValueException(_inner) => Some(_inner),
DeleteParameterGroupErrorKind::ParameterGroupNotFoundFault(_inner) => Some(_inner),
DeleteParameterGroupErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => Some(_inner),
DeleteParameterGroupErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DeleteClusterError {
pub kind: DeleteClusterErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for DeleteClusterError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: DeleteClusterErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DeleteClusterErrorKind {
ClusterNotFoundFault(crate::error::ClusterNotFoundFault),
InvalidClusterStateFault(crate::error::InvalidClusterStateFault),
InvalidParameterCombinationException(crate::error::InvalidParameterCombinationException),
InvalidParameterValueException(crate::error::InvalidParameterValueException),
ServiceLinkedRoleNotFoundFault(crate::error::ServiceLinkedRoleNotFoundFault),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for DeleteClusterError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
DeleteClusterErrorKind::ClusterNotFoundFault(_inner) => _inner.fmt(f),
DeleteClusterErrorKind::InvalidClusterStateFault(_inner) => _inner.fmt(f),
DeleteClusterErrorKind::InvalidParameterCombinationException(_inner) => _inner.fmt(f),
DeleteClusterErrorKind::InvalidParameterValueException(_inner) => _inner.fmt(f),
DeleteClusterErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => _inner.fmt(f),
DeleteClusterErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for DeleteClusterError {
fn code(&self) -> Option<&str> {
DeleteClusterError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl DeleteClusterError {
pub fn new(kind: DeleteClusterErrorKind, meta: aws_smithy_types::Error) -> Self {
Self { kind, meta }
}
pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
Self {
kind: DeleteClusterErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: DeleteClusterErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
}
}
pub fn message(&self) -> Option<&str> {
self.meta.message()
}
pub fn meta(&self) -> &aws_smithy_types::Error {
&self.meta
}
pub fn request_id(&self) -> Option<&str> {
self.meta.request_id()
}
pub fn code(&self) -> Option<&str> {
self.meta.code()
}
pub fn is_cluster_not_found_fault(&self) -> bool {
matches!(&self.kind, DeleteClusterErrorKind::ClusterNotFoundFault(_))
}
pub fn is_invalid_cluster_state_fault(&self) -> bool {
matches!(
&self.kind,
DeleteClusterErrorKind::InvalidClusterStateFault(_)
)
}
pub fn is_invalid_parameter_combination_exception(&self) -> bool {
matches!(
&self.kind,
DeleteClusterErrorKind::InvalidParameterCombinationException(_)
)
}
pub fn is_invalid_parameter_value_exception(&self) -> bool {
matches!(
&self.kind,
DeleteClusterErrorKind::InvalidParameterValueException(_)
)
}
pub fn is_service_linked_role_not_found_fault(&self) -> bool {
matches!(
&self.kind,
DeleteClusterErrorKind::ServiceLinkedRoleNotFoundFault(_)
)
}
}
impl std::error::Error for DeleteClusterError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
DeleteClusterErrorKind::ClusterNotFoundFault(_inner) => Some(_inner),
DeleteClusterErrorKind::InvalidClusterStateFault(_inner) => Some(_inner),
DeleteClusterErrorKind::InvalidParameterCombinationException(_inner) => Some(_inner),
DeleteClusterErrorKind::InvalidParameterValueException(_inner) => Some(_inner),
DeleteClusterErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => Some(_inner),
DeleteClusterErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DecreaseReplicationFactorError {
pub kind: DecreaseReplicationFactorErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for DecreaseReplicationFactorError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: DecreaseReplicationFactorErrorKind::Unhandled(crate::error::Unhandled::new(
source,
)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DecreaseReplicationFactorErrorKind {
ClusterNotFoundFault(crate::error::ClusterNotFoundFault),
InvalidClusterStateFault(crate::error::InvalidClusterStateFault),
InvalidParameterCombinationException(crate::error::InvalidParameterCombinationException),
InvalidParameterValueException(crate::error::InvalidParameterValueException),
NodeNotFoundFault(crate::error::NodeNotFoundFault),
ServiceLinkedRoleNotFoundFault(crate::error::ServiceLinkedRoleNotFoundFault),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for DecreaseReplicationFactorError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
DecreaseReplicationFactorErrorKind::ClusterNotFoundFault(_inner) => _inner.fmt(f),
DecreaseReplicationFactorErrorKind::InvalidClusterStateFault(_inner) => _inner.fmt(f),
DecreaseReplicationFactorErrorKind::InvalidParameterCombinationException(_inner) => {
_inner.fmt(f)
}
DecreaseReplicationFactorErrorKind::InvalidParameterValueException(_inner) => {
_inner.fmt(f)
}
DecreaseReplicationFactorErrorKind::NodeNotFoundFault(_inner) => _inner.fmt(f),
DecreaseReplicationFactorErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => {
_inner.fmt(f)
}
DecreaseReplicationFactorErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for DecreaseReplicationFactorError {
fn code(&self) -> Option<&str> {
DecreaseReplicationFactorError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl DecreaseReplicationFactorError {
pub fn new(kind: DecreaseReplicationFactorErrorKind, meta: aws_smithy_types::Error) -> Self {
Self { kind, meta }
}
pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
Self {
kind: DecreaseReplicationFactorErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: DecreaseReplicationFactorErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
}
}
pub fn message(&self) -> Option<&str> {
self.meta.message()
}
pub fn meta(&self) -> &aws_smithy_types::Error {
&self.meta
}
pub fn request_id(&self) -> Option<&str> {
self.meta.request_id()
}
pub fn code(&self) -> Option<&str> {
self.meta.code()
}
pub fn is_cluster_not_found_fault(&self) -> bool {
matches!(
&self.kind,
DecreaseReplicationFactorErrorKind::ClusterNotFoundFault(_)
)
}
pub fn is_invalid_cluster_state_fault(&self) -> bool {
matches!(
&self.kind,
DecreaseReplicationFactorErrorKind::InvalidClusterStateFault(_)
)
}
pub fn is_invalid_parameter_combination_exception(&self) -> bool {
matches!(
&self.kind,
DecreaseReplicationFactorErrorKind::InvalidParameterCombinationException(_)
)
}
pub fn is_invalid_parameter_value_exception(&self) -> bool {
matches!(
&self.kind,
DecreaseReplicationFactorErrorKind::InvalidParameterValueException(_)
)
}
pub fn is_node_not_found_fault(&self) -> bool {
matches!(
&self.kind,
DecreaseReplicationFactorErrorKind::NodeNotFoundFault(_)
)
}
pub fn is_service_linked_role_not_found_fault(&self) -> bool {
matches!(
&self.kind,
DecreaseReplicationFactorErrorKind::ServiceLinkedRoleNotFoundFault(_)
)
}
}
impl std::error::Error for DecreaseReplicationFactorError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
DecreaseReplicationFactorErrorKind::ClusterNotFoundFault(_inner) => Some(_inner),
DecreaseReplicationFactorErrorKind::InvalidClusterStateFault(_inner) => Some(_inner),
DecreaseReplicationFactorErrorKind::InvalidParameterCombinationException(_inner) => {
Some(_inner)
}
DecreaseReplicationFactorErrorKind::InvalidParameterValueException(_inner) => {
Some(_inner)
}
DecreaseReplicationFactorErrorKind::NodeNotFoundFault(_inner) => Some(_inner),
DecreaseReplicationFactorErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => {
Some(_inner)
}
DecreaseReplicationFactorErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct CreateSubnetGroupError {
pub kind: CreateSubnetGroupErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for CreateSubnetGroupError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: CreateSubnetGroupErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum CreateSubnetGroupErrorKind {
InvalidSubnet(crate::error::InvalidSubnet),
ServiceLinkedRoleNotFoundFault(crate::error::ServiceLinkedRoleNotFoundFault),
SubnetGroupAlreadyExistsFault(crate::error::SubnetGroupAlreadyExistsFault),
SubnetGroupQuotaExceededFault(crate::error::SubnetGroupQuotaExceededFault),
SubnetQuotaExceededFault(crate::error::SubnetQuotaExceededFault),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for CreateSubnetGroupError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
CreateSubnetGroupErrorKind::InvalidSubnet(_inner) => _inner.fmt(f),
CreateSubnetGroupErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => _inner.fmt(f),
CreateSubnetGroupErrorKind::SubnetGroupAlreadyExistsFault(_inner) => _inner.fmt(f),
CreateSubnetGroupErrorKind::SubnetGroupQuotaExceededFault(_inner) => _inner.fmt(f),
CreateSubnetGroupErrorKind::SubnetQuotaExceededFault(_inner) => _inner.fmt(f),
CreateSubnetGroupErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for CreateSubnetGroupError {
fn code(&self) -> Option<&str> {
CreateSubnetGroupError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl CreateSubnetGroupError {
pub fn new(kind: CreateSubnetGroupErrorKind, meta: aws_smithy_types::Error) -> Self {
Self { kind, meta }
}
pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
Self {
kind: CreateSubnetGroupErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: CreateSubnetGroupErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
}
}
pub fn message(&self) -> Option<&str> {
self.meta.message()
}
pub fn meta(&self) -> &aws_smithy_types::Error {
&self.meta
}
pub fn request_id(&self) -> Option<&str> {
self.meta.request_id()
}
pub fn code(&self) -> Option<&str> {
self.meta.code()
}
pub fn is_invalid_subnet(&self) -> bool {
matches!(&self.kind, CreateSubnetGroupErrorKind::InvalidSubnet(_))
}
pub fn is_service_linked_role_not_found_fault(&self) -> bool {
matches!(
&self.kind,
CreateSubnetGroupErrorKind::ServiceLinkedRoleNotFoundFault(_)
)
}
pub fn is_subnet_group_already_exists_fault(&self) -> bool {
matches!(
&self.kind,
CreateSubnetGroupErrorKind::SubnetGroupAlreadyExistsFault(_)
)
}
pub fn is_subnet_group_quota_exceeded_fault(&self) -> bool {
matches!(
&self.kind,
CreateSubnetGroupErrorKind::SubnetGroupQuotaExceededFault(_)
)
}
pub fn is_subnet_quota_exceeded_fault(&self) -> bool {
matches!(
&self.kind,
CreateSubnetGroupErrorKind::SubnetQuotaExceededFault(_)
)
}
}
impl std::error::Error for CreateSubnetGroupError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
CreateSubnetGroupErrorKind::InvalidSubnet(_inner) => Some(_inner),
CreateSubnetGroupErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => Some(_inner),
CreateSubnetGroupErrorKind::SubnetGroupAlreadyExistsFault(_inner) => Some(_inner),
CreateSubnetGroupErrorKind::SubnetGroupQuotaExceededFault(_inner) => Some(_inner),
CreateSubnetGroupErrorKind::SubnetQuotaExceededFault(_inner) => Some(_inner),
CreateSubnetGroupErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct SubnetGroupQuotaExceededFault {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl SubnetGroupQuotaExceededFault {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for SubnetGroupQuotaExceededFault {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "SubnetGroupQuotaExceededFault")?;
if let Some(inner_21) = &self.message {
{
write!(f, ": {}", inner_21)?;
}
}
Ok(())
}
}
impl std::error::Error for SubnetGroupQuotaExceededFault {}
pub mod subnet_group_quota_exceeded_fault {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::SubnetGroupQuotaExceededFault {
crate::error::SubnetGroupQuotaExceededFault {
message: self.message,
}
}
}
}
impl SubnetGroupQuotaExceededFault {
pub fn builder() -> crate::error::subnet_group_quota_exceeded_fault::Builder {
crate::error::subnet_group_quota_exceeded_fault::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct SubnetGroupAlreadyExistsFault {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl SubnetGroupAlreadyExistsFault {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for SubnetGroupAlreadyExistsFault {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "SubnetGroupAlreadyExistsFault")?;
if let Some(inner_22) = &self.message {
{
write!(f, ": {}", inner_22)?;
}
}
Ok(())
}
}
impl std::error::Error for SubnetGroupAlreadyExistsFault {}
pub mod subnet_group_already_exists_fault {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::SubnetGroupAlreadyExistsFault {
crate::error::SubnetGroupAlreadyExistsFault {
message: self.message,
}
}
}
}
impl SubnetGroupAlreadyExistsFault {
pub fn builder() -> crate::error::subnet_group_already_exists_fault::Builder {
crate::error::subnet_group_already_exists_fault::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct CreateParameterGroupError {
pub kind: CreateParameterGroupErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for CreateParameterGroupError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: CreateParameterGroupErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum CreateParameterGroupErrorKind {
InvalidParameterCombinationException(crate::error::InvalidParameterCombinationException),
InvalidParameterGroupStateFault(crate::error::InvalidParameterGroupStateFault),
InvalidParameterValueException(crate::error::InvalidParameterValueException),
ParameterGroupAlreadyExistsFault(crate::error::ParameterGroupAlreadyExistsFault),
ParameterGroupQuotaExceededFault(crate::error::ParameterGroupQuotaExceededFault),
ServiceLinkedRoleNotFoundFault(crate::error::ServiceLinkedRoleNotFoundFault),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for CreateParameterGroupError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
CreateParameterGroupErrorKind::InvalidParameterCombinationException(_inner) => {
_inner.fmt(f)
}
CreateParameterGroupErrorKind::InvalidParameterGroupStateFault(_inner) => _inner.fmt(f),
CreateParameterGroupErrorKind::InvalidParameterValueException(_inner) => _inner.fmt(f),
CreateParameterGroupErrorKind::ParameterGroupAlreadyExistsFault(_inner) => {
_inner.fmt(f)
}
CreateParameterGroupErrorKind::ParameterGroupQuotaExceededFault(_inner) => {
_inner.fmt(f)
}
CreateParameterGroupErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => _inner.fmt(f),
CreateParameterGroupErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for CreateParameterGroupError {
fn code(&self) -> Option<&str> {
CreateParameterGroupError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl CreateParameterGroupError {
pub fn new(kind: CreateParameterGroupErrorKind, meta: aws_smithy_types::Error) -> Self {
Self { kind, meta }
}
pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
Self {
kind: CreateParameterGroupErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: CreateParameterGroupErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
}
}
pub fn message(&self) -> Option<&str> {
self.meta.message()
}
pub fn meta(&self) -> &aws_smithy_types::Error {
&self.meta
}
pub fn request_id(&self) -> Option<&str> {
self.meta.request_id()
}
pub fn code(&self) -> Option<&str> {
self.meta.code()
}
pub fn is_invalid_parameter_combination_exception(&self) -> bool {
matches!(
&self.kind,
CreateParameterGroupErrorKind::InvalidParameterCombinationException(_)
)
}
pub fn is_invalid_parameter_group_state_fault(&self) -> bool {
matches!(
&self.kind,
CreateParameterGroupErrorKind::InvalidParameterGroupStateFault(_)
)
}
pub fn is_invalid_parameter_value_exception(&self) -> bool {
matches!(
&self.kind,
CreateParameterGroupErrorKind::InvalidParameterValueException(_)
)
}
pub fn is_parameter_group_already_exists_fault(&self) -> bool {
matches!(
&self.kind,
CreateParameterGroupErrorKind::ParameterGroupAlreadyExistsFault(_)
)
}
pub fn is_parameter_group_quota_exceeded_fault(&self) -> bool {
matches!(
&self.kind,
CreateParameterGroupErrorKind::ParameterGroupQuotaExceededFault(_)
)
}
pub fn is_service_linked_role_not_found_fault(&self) -> bool {
matches!(
&self.kind,
CreateParameterGroupErrorKind::ServiceLinkedRoleNotFoundFault(_)
)
}
}
impl std::error::Error for CreateParameterGroupError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
CreateParameterGroupErrorKind::InvalidParameterCombinationException(_inner) => {
Some(_inner)
}
CreateParameterGroupErrorKind::InvalidParameterGroupStateFault(_inner) => Some(_inner),
CreateParameterGroupErrorKind::InvalidParameterValueException(_inner) => Some(_inner),
CreateParameterGroupErrorKind::ParameterGroupAlreadyExistsFault(_inner) => Some(_inner),
CreateParameterGroupErrorKind::ParameterGroupQuotaExceededFault(_inner) => Some(_inner),
CreateParameterGroupErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => Some(_inner),
CreateParameterGroupErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ParameterGroupQuotaExceededFault {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl ParameterGroupQuotaExceededFault {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for ParameterGroupQuotaExceededFault {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "ParameterGroupQuotaExceededFault")?;
if let Some(inner_23) = &self.message {
{
write!(f, ": {}", inner_23)?;
}
}
Ok(())
}
}
impl std::error::Error for ParameterGroupQuotaExceededFault {}
pub mod parameter_group_quota_exceeded_fault {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::ParameterGroupQuotaExceededFault {
crate::error::ParameterGroupQuotaExceededFault {
message: self.message,
}
}
}
}
impl ParameterGroupQuotaExceededFault {
pub fn builder() -> crate::error::parameter_group_quota_exceeded_fault::Builder {
crate::error::parameter_group_quota_exceeded_fault::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ParameterGroupAlreadyExistsFault {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl ParameterGroupAlreadyExistsFault {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for ParameterGroupAlreadyExistsFault {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "ParameterGroupAlreadyExistsFault")?;
if let Some(inner_24) = &self.message {
{
write!(f, ": {}", inner_24)?;
}
}
Ok(())
}
}
impl std::error::Error for ParameterGroupAlreadyExistsFault {}
pub mod parameter_group_already_exists_fault {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::ParameterGroupAlreadyExistsFault {
crate::error::ParameterGroupAlreadyExistsFault {
message: self.message,
}
}
}
}
impl ParameterGroupAlreadyExistsFault {
pub fn builder() -> crate::error::parameter_group_already_exists_fault::Builder {
crate::error::parameter_group_already_exists_fault::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct CreateClusterError {
pub kind: CreateClusterErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for CreateClusterError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: CreateClusterErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum CreateClusterErrorKind {
ClusterAlreadyExistsFault(crate::error::ClusterAlreadyExistsFault),
ClusterQuotaForCustomerExceededFault(crate::error::ClusterQuotaForCustomerExceededFault),
InsufficientClusterCapacityFault(crate::error::InsufficientClusterCapacityFault),
InvalidClusterStateFault(crate::error::InvalidClusterStateFault),
InvalidParameterCombinationException(crate::error::InvalidParameterCombinationException),
InvalidParameterGroupStateFault(crate::error::InvalidParameterGroupStateFault),
InvalidParameterValueException(crate::error::InvalidParameterValueException),
InvalidVpcNetworkStateFault(crate::error::InvalidVpcNetworkStateFault),
NodeQuotaForClusterExceededFault(crate::error::NodeQuotaForClusterExceededFault),
NodeQuotaForCustomerExceededFault(crate::error::NodeQuotaForCustomerExceededFault),
ParameterGroupNotFoundFault(crate::error::ParameterGroupNotFoundFault),
ServiceLinkedRoleNotFoundFault(crate::error::ServiceLinkedRoleNotFoundFault),
ServiceQuotaExceededException(crate::error::ServiceQuotaExceededException),
SubnetGroupNotFoundFault(crate::error::SubnetGroupNotFoundFault),
TagQuotaPerResourceExceeded(crate::error::TagQuotaPerResourceExceeded),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for CreateClusterError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
CreateClusterErrorKind::ClusterAlreadyExistsFault(_inner) => _inner.fmt(f),
CreateClusterErrorKind::ClusterQuotaForCustomerExceededFault(_inner) => _inner.fmt(f),
CreateClusterErrorKind::InsufficientClusterCapacityFault(_inner) => _inner.fmt(f),
CreateClusterErrorKind::InvalidClusterStateFault(_inner) => _inner.fmt(f),
CreateClusterErrorKind::InvalidParameterCombinationException(_inner) => _inner.fmt(f),
CreateClusterErrorKind::InvalidParameterGroupStateFault(_inner) => _inner.fmt(f),
CreateClusterErrorKind::InvalidParameterValueException(_inner) => _inner.fmt(f),
CreateClusterErrorKind::InvalidVpcNetworkStateFault(_inner) => _inner.fmt(f),
CreateClusterErrorKind::NodeQuotaForClusterExceededFault(_inner) => _inner.fmt(f),
CreateClusterErrorKind::NodeQuotaForCustomerExceededFault(_inner) => _inner.fmt(f),
CreateClusterErrorKind::ParameterGroupNotFoundFault(_inner) => _inner.fmt(f),
CreateClusterErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => _inner.fmt(f),
CreateClusterErrorKind::ServiceQuotaExceededException(_inner) => _inner.fmt(f),
CreateClusterErrorKind::SubnetGroupNotFoundFault(_inner) => _inner.fmt(f),
CreateClusterErrorKind::TagQuotaPerResourceExceeded(_inner) => _inner.fmt(f),
CreateClusterErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for CreateClusterError {
fn code(&self) -> Option<&str> {
CreateClusterError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl CreateClusterError {
pub fn new(kind: CreateClusterErrorKind, meta: aws_smithy_types::Error) -> Self {
Self { kind, meta }
}
pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
Self {
kind: CreateClusterErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: CreateClusterErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
}
}
pub fn message(&self) -> Option<&str> {
self.meta.message()
}
pub fn meta(&self) -> &aws_smithy_types::Error {
&self.meta
}
pub fn request_id(&self) -> Option<&str> {
self.meta.request_id()
}
pub fn code(&self) -> Option<&str> {
self.meta.code()
}
pub fn is_cluster_already_exists_fault(&self) -> bool {
matches!(
&self.kind,
CreateClusterErrorKind::ClusterAlreadyExistsFault(_)
)
}
pub fn is_cluster_quota_for_customer_exceeded_fault(&self) -> bool {
matches!(
&self.kind,
CreateClusterErrorKind::ClusterQuotaForCustomerExceededFault(_)
)
}
pub fn is_insufficient_cluster_capacity_fault(&self) -> bool {
matches!(
&self.kind,
CreateClusterErrorKind::InsufficientClusterCapacityFault(_)
)
}
pub fn is_invalid_cluster_state_fault(&self) -> bool {
matches!(
&self.kind,
CreateClusterErrorKind::InvalidClusterStateFault(_)
)
}
pub fn is_invalid_parameter_combination_exception(&self) -> bool {
matches!(
&self.kind,
CreateClusterErrorKind::InvalidParameterCombinationException(_)
)
}
pub fn is_invalid_parameter_group_state_fault(&self) -> bool {
matches!(
&self.kind,
CreateClusterErrorKind::InvalidParameterGroupStateFault(_)
)
}
pub fn is_invalid_parameter_value_exception(&self) -> bool {
matches!(
&self.kind,
CreateClusterErrorKind::InvalidParameterValueException(_)
)
}
pub fn is_invalid_vpc_network_state_fault(&self) -> bool {
matches!(
&self.kind,
CreateClusterErrorKind::InvalidVpcNetworkStateFault(_)
)
}
pub fn is_node_quota_for_cluster_exceeded_fault(&self) -> bool {
matches!(
&self.kind,
CreateClusterErrorKind::NodeQuotaForClusterExceededFault(_)
)
}
pub fn is_node_quota_for_customer_exceeded_fault(&self) -> bool {
matches!(
&self.kind,
CreateClusterErrorKind::NodeQuotaForCustomerExceededFault(_)
)
}
pub fn is_parameter_group_not_found_fault(&self) -> bool {
matches!(
&self.kind,
CreateClusterErrorKind::ParameterGroupNotFoundFault(_)
)
}
pub fn is_service_linked_role_not_found_fault(&self) -> bool {
matches!(
&self.kind,
CreateClusterErrorKind::ServiceLinkedRoleNotFoundFault(_)
)
}
pub fn is_service_quota_exceeded_exception(&self) -> bool {
matches!(
&self.kind,
CreateClusterErrorKind::ServiceQuotaExceededException(_)
)
}
pub fn is_subnet_group_not_found_fault(&self) -> bool {
matches!(
&self.kind,
CreateClusterErrorKind::SubnetGroupNotFoundFault(_)
)
}
pub fn is_tag_quota_per_resource_exceeded(&self) -> bool {
matches!(
&self.kind,
CreateClusterErrorKind::TagQuotaPerResourceExceeded(_)
)
}
}
impl std::error::Error for CreateClusterError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
CreateClusterErrorKind::ClusterAlreadyExistsFault(_inner) => Some(_inner),
CreateClusterErrorKind::ClusterQuotaForCustomerExceededFault(_inner) => Some(_inner),
CreateClusterErrorKind::InsufficientClusterCapacityFault(_inner) => Some(_inner),
CreateClusterErrorKind::InvalidClusterStateFault(_inner) => Some(_inner),
CreateClusterErrorKind::InvalidParameterCombinationException(_inner) => Some(_inner),
CreateClusterErrorKind::InvalidParameterGroupStateFault(_inner) => Some(_inner),
CreateClusterErrorKind::InvalidParameterValueException(_inner) => Some(_inner),
CreateClusterErrorKind::InvalidVpcNetworkStateFault(_inner) => Some(_inner),
CreateClusterErrorKind::NodeQuotaForClusterExceededFault(_inner) => Some(_inner),
CreateClusterErrorKind::NodeQuotaForCustomerExceededFault(_inner) => Some(_inner),
CreateClusterErrorKind::ParameterGroupNotFoundFault(_inner) => Some(_inner),
CreateClusterErrorKind::ServiceLinkedRoleNotFoundFault(_inner) => Some(_inner),
CreateClusterErrorKind::ServiceQuotaExceededException(_inner) => Some(_inner),
CreateClusterErrorKind::SubnetGroupNotFoundFault(_inner) => Some(_inner),
CreateClusterErrorKind::TagQuotaPerResourceExceeded(_inner) => Some(_inner),
CreateClusterErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ServiceQuotaExceededException {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl ServiceQuotaExceededException {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for ServiceQuotaExceededException {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "ServiceQuotaExceededException")?;
if let Some(inner_25) = &self.message {
{
write!(f, ": {}", inner_25)?;
}
}
Ok(())
}
}
impl std::error::Error for ServiceQuotaExceededException {}
pub mod service_quota_exceeded_exception {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::ServiceQuotaExceededException {
crate::error::ServiceQuotaExceededException {
message: self.message,
}
}
}
}
impl ServiceQuotaExceededException {
pub fn builder() -> crate::error::service_quota_exceeded_exception::Builder {
crate::error::service_quota_exceeded_exception::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ClusterQuotaForCustomerExceededFault {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl ClusterQuotaForCustomerExceededFault {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for ClusterQuotaForCustomerExceededFault {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "ClusterQuotaForCustomerExceededFault")?;
if let Some(inner_26) = &self.message {
{
write!(f, ": {}", inner_26)?;
}
}
Ok(())
}
}
impl std::error::Error for ClusterQuotaForCustomerExceededFault {}
pub mod cluster_quota_for_customer_exceeded_fault {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::ClusterQuotaForCustomerExceededFault {
crate::error::ClusterQuotaForCustomerExceededFault {
message: self.message,
}
}
}
}
impl ClusterQuotaForCustomerExceededFault {
pub fn builder() -> crate::error::cluster_quota_for_customer_exceeded_fault::Builder {
crate::error::cluster_quota_for_customer_exceeded_fault::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ClusterAlreadyExistsFault {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl ClusterAlreadyExistsFault {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for ClusterAlreadyExistsFault {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "ClusterAlreadyExistsFault")?;
if let Some(inner_27) = &self.message {
{
write!(f, ": {}", inner_27)?;
}
}
Ok(())
}
}
impl std::error::Error for ClusterAlreadyExistsFault {}
pub mod cluster_already_exists_fault {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) message: std::option::Option<std::string::String>,
}
impl Builder {
#[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
self.message = Some(input.into());
self
}
#[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
self.message = input;
self
}
pub fn build(self) -> crate::error::ClusterAlreadyExistsFault {
crate::error::ClusterAlreadyExistsFault {
message: self.message,
}
}
}
}
impl ClusterAlreadyExistsFault {
pub fn builder() -> crate::error::cluster_already_exists_fault::Builder {
crate::error::cluster_already_exists_fault::Builder::default()
}
}
#[derive(Debug)]
pub struct Unhandled {
source: Box<dyn std::error::Error + Send + Sync + 'static>,
}
impl Unhandled {
#[allow(unused)]
pub(crate) fn new(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self { source }
}
}
impl std::fmt::Display for Unhandled {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
write!(f, "unhandled error")
}
}
impl std::error::Error for Unhandled {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
Some(self.source.as_ref() as _)
}
}