#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct UpdateVpcIngressConnectionError {
pub kind: UpdateVpcIngressConnectionErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for UpdateVpcIngressConnectionError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: UpdateVpcIngressConnectionErrorKind::Unhandled(crate::error::Unhandled::new(
source,
)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum UpdateVpcIngressConnectionErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
InvalidStateException(crate::error::InvalidStateException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for UpdateVpcIngressConnectionError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
UpdateVpcIngressConnectionErrorKind::InternalServiceErrorException(_inner) => {
_inner.fmt(f)
}
UpdateVpcIngressConnectionErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
UpdateVpcIngressConnectionErrorKind::InvalidStateException(_inner) => _inner.fmt(f),
UpdateVpcIngressConnectionErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
UpdateVpcIngressConnectionErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for UpdateVpcIngressConnectionError {
fn code(&self) -> Option<&str> {
UpdateVpcIngressConnectionError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl UpdateVpcIngressConnectionError {
pub fn new(kind: UpdateVpcIngressConnectionErrorKind, 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: UpdateVpcIngressConnectionErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: UpdateVpcIngressConnectionErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
UpdateVpcIngressConnectionErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
UpdateVpcIngressConnectionErrorKind::InvalidRequestException(_)
)
}
pub fn is_invalid_state_exception(&self) -> bool {
matches!(
&self.kind,
UpdateVpcIngressConnectionErrorKind::InvalidStateException(_)
)
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
UpdateVpcIngressConnectionErrorKind::ResourceNotFoundException(_)
)
}
}
impl std::error::Error for UpdateVpcIngressConnectionError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
UpdateVpcIngressConnectionErrorKind::InternalServiceErrorException(_inner) => {
Some(_inner)
}
UpdateVpcIngressConnectionErrorKind::InvalidRequestException(_inner) => Some(_inner),
UpdateVpcIngressConnectionErrorKind::InvalidStateException(_inner) => Some(_inner),
UpdateVpcIngressConnectionErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
UpdateVpcIngressConnectionErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ResourceNotFoundException {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl ResourceNotFoundException {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for ResourceNotFoundException {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "ResourceNotFoundException")?;
if let Some(inner_1) = &self.message {
{
write!(f, ": {}", inner_1)?;
}
}
Ok(())
}
}
impl std::error::Error for ResourceNotFoundException {}
pub mod resource_not_found_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::ResourceNotFoundException {
crate::error::ResourceNotFoundException {
message: self.message,
}
}
}
}
impl ResourceNotFoundException {
pub fn builder() -> crate::error::resource_not_found_exception::Builder {
crate::error::resource_not_found_exception::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct InvalidStateException {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl InvalidStateException {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for InvalidStateException {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "InvalidStateException")?;
if let Some(inner_2) = &self.message {
{
write!(f, ": {}", inner_2)?;
}
}
Ok(())
}
}
impl std::error::Error for InvalidStateException {}
pub mod invalid_state_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::InvalidStateException {
crate::error::InvalidStateException {
message: self.message,
}
}
}
}
impl InvalidStateException {
pub fn builder() -> crate::error::invalid_state_exception::Builder {
crate::error::invalid_state_exception::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct InvalidRequestException {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl InvalidRequestException {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for InvalidRequestException {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "InvalidRequestException")?;
if let Some(inner_3) = &self.message {
{
write!(f, ": {}", inner_3)?;
}
}
Ok(())
}
}
impl std::error::Error for InvalidRequestException {}
pub mod invalid_request_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::InvalidRequestException {
crate::error::InvalidRequestException {
message: self.message,
}
}
}
}
impl InvalidRequestException {
pub fn builder() -> crate::error::invalid_request_exception::Builder {
crate::error::invalid_request_exception::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct InternalServiceErrorException {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl InternalServiceErrorException {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for InternalServiceErrorException {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "InternalServiceErrorException")?;
if let Some(inner_4) = &self.message {
{
write!(f, ": {}", inner_4)?;
}
}
Ok(())
}
}
impl std::error::Error for InternalServiceErrorException {}
pub mod internal_service_error_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::InternalServiceErrorException {
crate::error::InternalServiceErrorException {
message: self.message,
}
}
}
}
impl InternalServiceErrorException {
pub fn builder() -> crate::error::internal_service_error_exception::Builder {
crate::error::internal_service_error_exception::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct UpdateServiceError {
pub kind: UpdateServiceErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for UpdateServiceError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: UpdateServiceErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum UpdateServiceErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
InvalidStateException(crate::error::InvalidStateException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for UpdateServiceError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
UpdateServiceErrorKind::InternalServiceErrorException(_inner) => _inner.fmt(f),
UpdateServiceErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
UpdateServiceErrorKind::InvalidStateException(_inner) => _inner.fmt(f),
UpdateServiceErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
UpdateServiceErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for UpdateServiceError {
fn code(&self) -> Option<&str> {
UpdateServiceError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl UpdateServiceError {
pub fn new(kind: UpdateServiceErrorKind, 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: UpdateServiceErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: UpdateServiceErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
UpdateServiceErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
UpdateServiceErrorKind::InvalidRequestException(_)
)
}
pub fn is_invalid_state_exception(&self) -> bool {
matches!(&self.kind, UpdateServiceErrorKind::InvalidStateException(_))
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
UpdateServiceErrorKind::ResourceNotFoundException(_)
)
}
}
impl std::error::Error for UpdateServiceError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
UpdateServiceErrorKind::InternalServiceErrorException(_inner) => Some(_inner),
UpdateServiceErrorKind::InvalidRequestException(_inner) => Some(_inner),
UpdateServiceErrorKind::InvalidStateException(_inner) => Some(_inner),
UpdateServiceErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
UpdateServiceErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[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 {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
InvalidStateException(crate::error::InvalidStateException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
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::InternalServiceErrorException(_inner) => _inner.fmt(f),
UntagResourceErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
UntagResourceErrorKind::InvalidStateException(_inner) => _inner.fmt(f),
UntagResourceErrorKind::ResourceNotFoundException(_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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
UntagResourceErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
UntagResourceErrorKind::InvalidRequestException(_)
)
}
pub fn is_invalid_state_exception(&self) -> bool {
matches!(&self.kind, UntagResourceErrorKind::InvalidStateException(_))
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
UntagResourceErrorKind::ResourceNotFoundException(_)
)
}
}
impl std::error::Error for UntagResourceError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
UntagResourceErrorKind::InternalServiceErrorException(_inner) => Some(_inner),
UntagResourceErrorKind::InvalidRequestException(_inner) => Some(_inner),
UntagResourceErrorKind::InvalidStateException(_inner) => Some(_inner),
UntagResourceErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
UntagResourceErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[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 {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
InvalidStateException(crate::error::InvalidStateException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
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::InternalServiceErrorException(_inner) => _inner.fmt(f),
TagResourceErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
TagResourceErrorKind::InvalidStateException(_inner) => _inner.fmt(f),
TagResourceErrorKind::ResourceNotFoundException(_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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
TagResourceErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(&self.kind, TagResourceErrorKind::InvalidRequestException(_))
}
pub fn is_invalid_state_exception(&self) -> bool {
matches!(&self.kind, TagResourceErrorKind::InvalidStateException(_))
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
TagResourceErrorKind::ResourceNotFoundException(_)
)
}
}
impl std::error::Error for TagResourceError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
TagResourceErrorKind::InternalServiceErrorException(_inner) => Some(_inner),
TagResourceErrorKind::InvalidRequestException(_inner) => Some(_inner),
TagResourceErrorKind::InvalidStateException(_inner) => Some(_inner),
TagResourceErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
TagResourceErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct StartDeploymentError {
pub kind: StartDeploymentErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for StartDeploymentError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: StartDeploymentErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum StartDeploymentErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for StartDeploymentError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
StartDeploymentErrorKind::InternalServiceErrorException(_inner) => _inner.fmt(f),
StartDeploymentErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
StartDeploymentErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
StartDeploymentErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for StartDeploymentError {
fn code(&self) -> Option<&str> {
StartDeploymentError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl StartDeploymentError {
pub fn new(kind: StartDeploymentErrorKind, 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: StartDeploymentErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: StartDeploymentErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
StartDeploymentErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
StartDeploymentErrorKind::InvalidRequestException(_)
)
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
StartDeploymentErrorKind::ResourceNotFoundException(_)
)
}
}
impl std::error::Error for StartDeploymentError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
StartDeploymentErrorKind::InternalServiceErrorException(_inner) => Some(_inner),
StartDeploymentErrorKind::InvalidRequestException(_inner) => Some(_inner),
StartDeploymentErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
StartDeploymentErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ResumeServiceError {
pub kind: ResumeServiceErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for ResumeServiceError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: ResumeServiceErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ResumeServiceErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
InvalidStateException(crate::error::InvalidStateException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for ResumeServiceError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
ResumeServiceErrorKind::InternalServiceErrorException(_inner) => _inner.fmt(f),
ResumeServiceErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
ResumeServiceErrorKind::InvalidStateException(_inner) => _inner.fmt(f),
ResumeServiceErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
ResumeServiceErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for ResumeServiceError {
fn code(&self) -> Option<&str> {
ResumeServiceError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl ResumeServiceError {
pub fn new(kind: ResumeServiceErrorKind, 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: ResumeServiceErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: ResumeServiceErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
ResumeServiceErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
ResumeServiceErrorKind::InvalidRequestException(_)
)
}
pub fn is_invalid_state_exception(&self) -> bool {
matches!(&self.kind, ResumeServiceErrorKind::InvalidStateException(_))
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
ResumeServiceErrorKind::ResourceNotFoundException(_)
)
}
}
impl std::error::Error for ResumeServiceError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
ResumeServiceErrorKind::InternalServiceErrorException(_inner) => Some(_inner),
ResumeServiceErrorKind::InvalidRequestException(_inner) => Some(_inner),
ResumeServiceErrorKind::InvalidStateException(_inner) => Some(_inner),
ResumeServiceErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
ResumeServiceErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct PauseServiceError {
pub kind: PauseServiceErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for PauseServiceError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: PauseServiceErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum PauseServiceErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
InvalidStateException(crate::error::InvalidStateException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for PauseServiceError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
PauseServiceErrorKind::InternalServiceErrorException(_inner) => _inner.fmt(f),
PauseServiceErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
PauseServiceErrorKind::InvalidStateException(_inner) => _inner.fmt(f),
PauseServiceErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
PauseServiceErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for PauseServiceError {
fn code(&self) -> Option<&str> {
PauseServiceError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl PauseServiceError {
pub fn new(kind: PauseServiceErrorKind, 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: PauseServiceErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: PauseServiceErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
PauseServiceErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
PauseServiceErrorKind::InvalidRequestException(_)
)
}
pub fn is_invalid_state_exception(&self) -> bool {
matches!(&self.kind, PauseServiceErrorKind::InvalidStateException(_))
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
PauseServiceErrorKind::ResourceNotFoundException(_)
)
}
}
impl std::error::Error for PauseServiceError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
PauseServiceErrorKind::InternalServiceErrorException(_inner) => Some(_inner),
PauseServiceErrorKind::InvalidRequestException(_inner) => Some(_inner),
PauseServiceErrorKind::InvalidStateException(_inner) => Some(_inner),
PauseServiceErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
PauseServiceErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListVpcIngressConnectionsError {
pub kind: ListVpcIngressConnectionsErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for ListVpcIngressConnectionsError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: ListVpcIngressConnectionsErrorKind::Unhandled(crate::error::Unhandled::new(
source,
)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListVpcIngressConnectionsErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for ListVpcIngressConnectionsError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
ListVpcIngressConnectionsErrorKind::InternalServiceErrorException(_inner) => {
_inner.fmt(f)
}
ListVpcIngressConnectionsErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
ListVpcIngressConnectionsErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for ListVpcIngressConnectionsError {
fn code(&self) -> Option<&str> {
ListVpcIngressConnectionsError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl ListVpcIngressConnectionsError {
pub fn new(kind: ListVpcIngressConnectionsErrorKind, 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: ListVpcIngressConnectionsErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: ListVpcIngressConnectionsErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
ListVpcIngressConnectionsErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
ListVpcIngressConnectionsErrorKind::InvalidRequestException(_)
)
}
}
impl std::error::Error for ListVpcIngressConnectionsError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
ListVpcIngressConnectionsErrorKind::InternalServiceErrorException(_inner) => {
Some(_inner)
}
ListVpcIngressConnectionsErrorKind::InvalidRequestException(_inner) => Some(_inner),
ListVpcIngressConnectionsErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListVpcConnectorsError {
pub kind: ListVpcConnectorsErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for ListVpcConnectorsError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: ListVpcConnectorsErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListVpcConnectorsErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for ListVpcConnectorsError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
ListVpcConnectorsErrorKind::InternalServiceErrorException(_inner) => _inner.fmt(f),
ListVpcConnectorsErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
ListVpcConnectorsErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for ListVpcConnectorsError {
fn code(&self) -> Option<&str> {
ListVpcConnectorsError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl ListVpcConnectorsError {
pub fn new(kind: ListVpcConnectorsErrorKind, 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: ListVpcConnectorsErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: ListVpcConnectorsErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
ListVpcConnectorsErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
ListVpcConnectorsErrorKind::InvalidRequestException(_)
)
}
}
impl std::error::Error for ListVpcConnectorsError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
ListVpcConnectorsErrorKind::InternalServiceErrorException(_inner) => Some(_inner),
ListVpcConnectorsErrorKind::InvalidRequestException(_inner) => Some(_inner),
ListVpcConnectorsErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListTagsForResourceError {
pub kind: ListTagsForResourceErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for ListTagsForResourceError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: ListTagsForResourceErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListTagsForResourceErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
InvalidStateException(crate::error::InvalidStateException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for ListTagsForResourceError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
ListTagsForResourceErrorKind::InternalServiceErrorException(_inner) => _inner.fmt(f),
ListTagsForResourceErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
ListTagsForResourceErrorKind::InvalidStateException(_inner) => _inner.fmt(f),
ListTagsForResourceErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
ListTagsForResourceErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for ListTagsForResourceError {
fn code(&self) -> Option<&str> {
ListTagsForResourceError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl ListTagsForResourceError {
pub fn new(kind: ListTagsForResourceErrorKind, 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: ListTagsForResourceErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: ListTagsForResourceErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
ListTagsForResourceErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
ListTagsForResourceErrorKind::InvalidRequestException(_)
)
}
pub fn is_invalid_state_exception(&self) -> bool {
matches!(
&self.kind,
ListTagsForResourceErrorKind::InvalidStateException(_)
)
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
ListTagsForResourceErrorKind::ResourceNotFoundException(_)
)
}
}
impl std::error::Error for ListTagsForResourceError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
ListTagsForResourceErrorKind::InternalServiceErrorException(_inner) => Some(_inner),
ListTagsForResourceErrorKind::InvalidRequestException(_inner) => Some(_inner),
ListTagsForResourceErrorKind::InvalidStateException(_inner) => Some(_inner),
ListTagsForResourceErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
ListTagsForResourceErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListServicesError {
pub kind: ListServicesErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for ListServicesError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: ListServicesErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListServicesErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for ListServicesError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
ListServicesErrorKind::InternalServiceErrorException(_inner) => _inner.fmt(f),
ListServicesErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
ListServicesErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for ListServicesError {
fn code(&self) -> Option<&str> {
ListServicesError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl ListServicesError {
pub fn new(kind: ListServicesErrorKind, 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: ListServicesErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: ListServicesErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
ListServicesErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
ListServicesErrorKind::InvalidRequestException(_)
)
}
}
impl std::error::Error for ListServicesError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
ListServicesErrorKind::InternalServiceErrorException(_inner) => Some(_inner),
ListServicesErrorKind::InvalidRequestException(_inner) => Some(_inner),
ListServicesErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListOperationsError {
pub kind: ListOperationsErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for ListOperationsError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: ListOperationsErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListOperationsErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for ListOperationsError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
ListOperationsErrorKind::InternalServiceErrorException(_inner) => _inner.fmt(f),
ListOperationsErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
ListOperationsErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
ListOperationsErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for ListOperationsError {
fn code(&self) -> Option<&str> {
ListOperationsError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl ListOperationsError {
pub fn new(kind: ListOperationsErrorKind, 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: ListOperationsErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: ListOperationsErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
ListOperationsErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
ListOperationsErrorKind::InvalidRequestException(_)
)
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
ListOperationsErrorKind::ResourceNotFoundException(_)
)
}
}
impl std::error::Error for ListOperationsError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
ListOperationsErrorKind::InternalServiceErrorException(_inner) => Some(_inner),
ListOperationsErrorKind::InvalidRequestException(_inner) => Some(_inner),
ListOperationsErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
ListOperationsErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListObservabilityConfigurationsError {
pub kind: ListObservabilityConfigurationsErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for ListObservabilityConfigurationsError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: ListObservabilityConfigurationsErrorKind::Unhandled(
crate::error::Unhandled::new(source),
),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListObservabilityConfigurationsErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for ListObservabilityConfigurationsError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
ListObservabilityConfigurationsErrorKind::InternalServiceErrorException(_inner) => {
_inner.fmt(f)
}
ListObservabilityConfigurationsErrorKind::InvalidRequestException(_inner) => {
_inner.fmt(f)
}
ListObservabilityConfigurationsErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for ListObservabilityConfigurationsError {
fn code(&self) -> Option<&str> {
ListObservabilityConfigurationsError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl ListObservabilityConfigurationsError {
pub fn new(
kind: ListObservabilityConfigurationsErrorKind,
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: ListObservabilityConfigurationsErrorKind::Unhandled(
crate::error::Unhandled::new(err.into()),
),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: ListObservabilityConfigurationsErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
ListObservabilityConfigurationsErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
ListObservabilityConfigurationsErrorKind::InvalidRequestException(_)
)
}
}
impl std::error::Error for ListObservabilityConfigurationsError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
ListObservabilityConfigurationsErrorKind::InternalServiceErrorException(_inner) => {
Some(_inner)
}
ListObservabilityConfigurationsErrorKind::InvalidRequestException(_inner) => {
Some(_inner)
}
ListObservabilityConfigurationsErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListConnectionsError {
pub kind: ListConnectionsErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for ListConnectionsError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: ListConnectionsErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListConnectionsErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for ListConnectionsError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
ListConnectionsErrorKind::InternalServiceErrorException(_inner) => _inner.fmt(f),
ListConnectionsErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
ListConnectionsErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for ListConnectionsError {
fn code(&self) -> Option<&str> {
ListConnectionsError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl ListConnectionsError {
pub fn new(kind: ListConnectionsErrorKind, 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: ListConnectionsErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: ListConnectionsErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
ListConnectionsErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
ListConnectionsErrorKind::InvalidRequestException(_)
)
}
}
impl std::error::Error for ListConnectionsError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
ListConnectionsErrorKind::InternalServiceErrorException(_inner) => Some(_inner),
ListConnectionsErrorKind::InvalidRequestException(_inner) => Some(_inner),
ListConnectionsErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListAutoScalingConfigurationsError {
pub kind: ListAutoScalingConfigurationsErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for ListAutoScalingConfigurationsError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: ListAutoScalingConfigurationsErrorKind::Unhandled(crate::error::Unhandled::new(
source,
)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListAutoScalingConfigurationsErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for ListAutoScalingConfigurationsError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
ListAutoScalingConfigurationsErrorKind::InternalServiceErrorException(_inner) => {
_inner.fmt(f)
}
ListAutoScalingConfigurationsErrorKind::InvalidRequestException(_inner) => {
_inner.fmt(f)
}
ListAutoScalingConfigurationsErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for ListAutoScalingConfigurationsError {
fn code(&self) -> Option<&str> {
ListAutoScalingConfigurationsError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl ListAutoScalingConfigurationsError {
pub fn new(
kind: ListAutoScalingConfigurationsErrorKind,
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: ListAutoScalingConfigurationsErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: ListAutoScalingConfigurationsErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
ListAutoScalingConfigurationsErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
ListAutoScalingConfigurationsErrorKind::InvalidRequestException(_)
)
}
}
impl std::error::Error for ListAutoScalingConfigurationsError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
ListAutoScalingConfigurationsErrorKind::InternalServiceErrorException(_inner) => {
Some(_inner)
}
ListAutoScalingConfigurationsErrorKind::InvalidRequestException(_inner) => Some(_inner),
ListAutoScalingConfigurationsErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DisassociateCustomDomainError {
pub kind: DisassociateCustomDomainErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for DisassociateCustomDomainError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: DisassociateCustomDomainErrorKind::Unhandled(crate::error::Unhandled::new(
source,
)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DisassociateCustomDomainErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
InvalidStateException(crate::error::InvalidStateException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for DisassociateCustomDomainError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
DisassociateCustomDomainErrorKind::InternalServiceErrorException(_inner) => {
_inner.fmt(f)
}
DisassociateCustomDomainErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
DisassociateCustomDomainErrorKind::InvalidStateException(_inner) => _inner.fmt(f),
DisassociateCustomDomainErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
DisassociateCustomDomainErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for DisassociateCustomDomainError {
fn code(&self) -> Option<&str> {
DisassociateCustomDomainError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl DisassociateCustomDomainError {
pub fn new(kind: DisassociateCustomDomainErrorKind, 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: DisassociateCustomDomainErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: DisassociateCustomDomainErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
DisassociateCustomDomainErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
DisassociateCustomDomainErrorKind::InvalidRequestException(_)
)
}
pub fn is_invalid_state_exception(&self) -> bool {
matches!(
&self.kind,
DisassociateCustomDomainErrorKind::InvalidStateException(_)
)
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
DisassociateCustomDomainErrorKind::ResourceNotFoundException(_)
)
}
}
impl std::error::Error for DisassociateCustomDomainError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
DisassociateCustomDomainErrorKind::InternalServiceErrorException(_inner) => {
Some(_inner)
}
DisassociateCustomDomainErrorKind::InvalidRequestException(_inner) => Some(_inner),
DisassociateCustomDomainErrorKind::InvalidStateException(_inner) => Some(_inner),
DisassociateCustomDomainErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
DisassociateCustomDomainErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DescribeVpcIngressConnectionError {
pub kind: DescribeVpcIngressConnectionErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for DescribeVpcIngressConnectionError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: DescribeVpcIngressConnectionErrorKind::Unhandled(crate::error::Unhandled::new(
source,
)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DescribeVpcIngressConnectionErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for DescribeVpcIngressConnectionError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
DescribeVpcIngressConnectionErrorKind::InternalServiceErrorException(_inner) => {
_inner.fmt(f)
}
DescribeVpcIngressConnectionErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
DescribeVpcIngressConnectionErrorKind::ResourceNotFoundException(_inner) => {
_inner.fmt(f)
}
DescribeVpcIngressConnectionErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for DescribeVpcIngressConnectionError {
fn code(&self) -> Option<&str> {
DescribeVpcIngressConnectionError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl DescribeVpcIngressConnectionError {
pub fn new(kind: DescribeVpcIngressConnectionErrorKind, 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: DescribeVpcIngressConnectionErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: DescribeVpcIngressConnectionErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
DescribeVpcIngressConnectionErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
DescribeVpcIngressConnectionErrorKind::InvalidRequestException(_)
)
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
DescribeVpcIngressConnectionErrorKind::ResourceNotFoundException(_)
)
}
}
impl std::error::Error for DescribeVpcIngressConnectionError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
DescribeVpcIngressConnectionErrorKind::InternalServiceErrorException(_inner) => {
Some(_inner)
}
DescribeVpcIngressConnectionErrorKind::InvalidRequestException(_inner) => Some(_inner),
DescribeVpcIngressConnectionErrorKind::ResourceNotFoundException(_inner) => {
Some(_inner)
}
DescribeVpcIngressConnectionErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DescribeVpcConnectorError {
pub kind: DescribeVpcConnectorErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for DescribeVpcConnectorError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: DescribeVpcConnectorErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DescribeVpcConnectorErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for DescribeVpcConnectorError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
DescribeVpcConnectorErrorKind::InternalServiceErrorException(_inner) => _inner.fmt(f),
DescribeVpcConnectorErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
DescribeVpcConnectorErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
DescribeVpcConnectorErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for DescribeVpcConnectorError {
fn code(&self) -> Option<&str> {
DescribeVpcConnectorError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl DescribeVpcConnectorError {
pub fn new(kind: DescribeVpcConnectorErrorKind, 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: DescribeVpcConnectorErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: DescribeVpcConnectorErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
DescribeVpcConnectorErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
DescribeVpcConnectorErrorKind::InvalidRequestException(_)
)
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
DescribeVpcConnectorErrorKind::ResourceNotFoundException(_)
)
}
}
impl std::error::Error for DescribeVpcConnectorError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
DescribeVpcConnectorErrorKind::InternalServiceErrorException(_inner) => Some(_inner),
DescribeVpcConnectorErrorKind::InvalidRequestException(_inner) => Some(_inner),
DescribeVpcConnectorErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
DescribeVpcConnectorErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DescribeServiceError {
pub kind: DescribeServiceErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for DescribeServiceError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: DescribeServiceErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DescribeServiceErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for DescribeServiceError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
DescribeServiceErrorKind::InternalServiceErrorException(_inner) => _inner.fmt(f),
DescribeServiceErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
DescribeServiceErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
DescribeServiceErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for DescribeServiceError {
fn code(&self) -> Option<&str> {
DescribeServiceError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl DescribeServiceError {
pub fn new(kind: DescribeServiceErrorKind, 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: DescribeServiceErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: DescribeServiceErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
DescribeServiceErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
DescribeServiceErrorKind::InvalidRequestException(_)
)
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
DescribeServiceErrorKind::ResourceNotFoundException(_)
)
}
}
impl std::error::Error for DescribeServiceError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
DescribeServiceErrorKind::InternalServiceErrorException(_inner) => Some(_inner),
DescribeServiceErrorKind::InvalidRequestException(_inner) => Some(_inner),
DescribeServiceErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
DescribeServiceErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DescribeObservabilityConfigurationError {
pub kind: DescribeObservabilityConfigurationErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for DescribeObservabilityConfigurationError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: DescribeObservabilityConfigurationErrorKind::Unhandled(
crate::error::Unhandled::new(source),
),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DescribeObservabilityConfigurationErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for DescribeObservabilityConfigurationError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
DescribeObservabilityConfigurationErrorKind::InternalServiceErrorException(_inner) => {
_inner.fmt(f)
}
DescribeObservabilityConfigurationErrorKind::InvalidRequestException(_inner) => {
_inner.fmt(f)
}
DescribeObservabilityConfigurationErrorKind::ResourceNotFoundException(_inner) => {
_inner.fmt(f)
}
DescribeObservabilityConfigurationErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for DescribeObservabilityConfigurationError {
fn code(&self) -> Option<&str> {
DescribeObservabilityConfigurationError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl DescribeObservabilityConfigurationError {
pub fn new(
kind: DescribeObservabilityConfigurationErrorKind,
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: DescribeObservabilityConfigurationErrorKind::Unhandled(
crate::error::Unhandled::new(err.into()),
),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: DescribeObservabilityConfigurationErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
DescribeObservabilityConfigurationErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
DescribeObservabilityConfigurationErrorKind::InvalidRequestException(_)
)
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
DescribeObservabilityConfigurationErrorKind::ResourceNotFoundException(_)
)
}
}
impl std::error::Error for DescribeObservabilityConfigurationError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
DescribeObservabilityConfigurationErrorKind::InternalServiceErrorException(_inner) => {
Some(_inner)
}
DescribeObservabilityConfigurationErrorKind::InvalidRequestException(_inner) => {
Some(_inner)
}
DescribeObservabilityConfigurationErrorKind::ResourceNotFoundException(_inner) => {
Some(_inner)
}
DescribeObservabilityConfigurationErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DescribeCustomDomainsError {
pub kind: DescribeCustomDomainsErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for DescribeCustomDomainsError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: DescribeCustomDomainsErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DescribeCustomDomainsErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for DescribeCustomDomainsError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
DescribeCustomDomainsErrorKind::InternalServiceErrorException(_inner) => _inner.fmt(f),
DescribeCustomDomainsErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
DescribeCustomDomainsErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
DescribeCustomDomainsErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for DescribeCustomDomainsError {
fn code(&self) -> Option<&str> {
DescribeCustomDomainsError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl DescribeCustomDomainsError {
pub fn new(kind: DescribeCustomDomainsErrorKind, 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: DescribeCustomDomainsErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: DescribeCustomDomainsErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
DescribeCustomDomainsErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
DescribeCustomDomainsErrorKind::InvalidRequestException(_)
)
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
DescribeCustomDomainsErrorKind::ResourceNotFoundException(_)
)
}
}
impl std::error::Error for DescribeCustomDomainsError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
DescribeCustomDomainsErrorKind::InternalServiceErrorException(_inner) => Some(_inner),
DescribeCustomDomainsErrorKind::InvalidRequestException(_inner) => Some(_inner),
DescribeCustomDomainsErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
DescribeCustomDomainsErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DescribeAutoScalingConfigurationError {
pub kind: DescribeAutoScalingConfigurationErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for DescribeAutoScalingConfigurationError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: DescribeAutoScalingConfigurationErrorKind::Unhandled(
crate::error::Unhandled::new(source),
),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DescribeAutoScalingConfigurationErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for DescribeAutoScalingConfigurationError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
DescribeAutoScalingConfigurationErrorKind::InternalServiceErrorException(_inner) => {
_inner.fmt(f)
}
DescribeAutoScalingConfigurationErrorKind::InvalidRequestException(_inner) => {
_inner.fmt(f)
}
DescribeAutoScalingConfigurationErrorKind::ResourceNotFoundException(_inner) => {
_inner.fmt(f)
}
DescribeAutoScalingConfigurationErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for DescribeAutoScalingConfigurationError {
fn code(&self) -> Option<&str> {
DescribeAutoScalingConfigurationError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl DescribeAutoScalingConfigurationError {
pub fn new(
kind: DescribeAutoScalingConfigurationErrorKind,
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: DescribeAutoScalingConfigurationErrorKind::Unhandled(
crate::error::Unhandled::new(err.into()),
),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: DescribeAutoScalingConfigurationErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
DescribeAutoScalingConfigurationErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
DescribeAutoScalingConfigurationErrorKind::InvalidRequestException(_)
)
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
DescribeAutoScalingConfigurationErrorKind::ResourceNotFoundException(_)
)
}
}
impl std::error::Error for DescribeAutoScalingConfigurationError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
DescribeAutoScalingConfigurationErrorKind::InternalServiceErrorException(_inner) => {
Some(_inner)
}
DescribeAutoScalingConfigurationErrorKind::InvalidRequestException(_inner) => {
Some(_inner)
}
DescribeAutoScalingConfigurationErrorKind::ResourceNotFoundException(_inner) => {
Some(_inner)
}
DescribeAutoScalingConfigurationErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DeleteVpcIngressConnectionError {
pub kind: DeleteVpcIngressConnectionErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for DeleteVpcIngressConnectionError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: DeleteVpcIngressConnectionErrorKind::Unhandled(crate::error::Unhandled::new(
source,
)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DeleteVpcIngressConnectionErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
InvalidStateException(crate::error::InvalidStateException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for DeleteVpcIngressConnectionError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
DeleteVpcIngressConnectionErrorKind::InternalServiceErrorException(_inner) => {
_inner.fmt(f)
}
DeleteVpcIngressConnectionErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
DeleteVpcIngressConnectionErrorKind::InvalidStateException(_inner) => _inner.fmt(f),
DeleteVpcIngressConnectionErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
DeleteVpcIngressConnectionErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for DeleteVpcIngressConnectionError {
fn code(&self) -> Option<&str> {
DeleteVpcIngressConnectionError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl DeleteVpcIngressConnectionError {
pub fn new(kind: DeleteVpcIngressConnectionErrorKind, 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: DeleteVpcIngressConnectionErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: DeleteVpcIngressConnectionErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
DeleteVpcIngressConnectionErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
DeleteVpcIngressConnectionErrorKind::InvalidRequestException(_)
)
}
pub fn is_invalid_state_exception(&self) -> bool {
matches!(
&self.kind,
DeleteVpcIngressConnectionErrorKind::InvalidStateException(_)
)
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
DeleteVpcIngressConnectionErrorKind::ResourceNotFoundException(_)
)
}
}
impl std::error::Error for DeleteVpcIngressConnectionError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
DeleteVpcIngressConnectionErrorKind::InternalServiceErrorException(_inner) => {
Some(_inner)
}
DeleteVpcIngressConnectionErrorKind::InvalidRequestException(_inner) => Some(_inner),
DeleteVpcIngressConnectionErrorKind::InvalidStateException(_inner) => Some(_inner),
DeleteVpcIngressConnectionErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
DeleteVpcIngressConnectionErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DeleteVpcConnectorError {
pub kind: DeleteVpcConnectorErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for DeleteVpcConnectorError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: DeleteVpcConnectorErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DeleteVpcConnectorErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for DeleteVpcConnectorError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
DeleteVpcConnectorErrorKind::InternalServiceErrorException(_inner) => _inner.fmt(f),
DeleteVpcConnectorErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
DeleteVpcConnectorErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
DeleteVpcConnectorErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for DeleteVpcConnectorError {
fn code(&self) -> Option<&str> {
DeleteVpcConnectorError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl DeleteVpcConnectorError {
pub fn new(kind: DeleteVpcConnectorErrorKind, 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: DeleteVpcConnectorErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: DeleteVpcConnectorErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
DeleteVpcConnectorErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
DeleteVpcConnectorErrorKind::InvalidRequestException(_)
)
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
DeleteVpcConnectorErrorKind::ResourceNotFoundException(_)
)
}
}
impl std::error::Error for DeleteVpcConnectorError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
DeleteVpcConnectorErrorKind::InternalServiceErrorException(_inner) => Some(_inner),
DeleteVpcConnectorErrorKind::InvalidRequestException(_inner) => Some(_inner),
DeleteVpcConnectorErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
DeleteVpcConnectorErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DeleteServiceError {
pub kind: DeleteServiceErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for DeleteServiceError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: DeleteServiceErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DeleteServiceErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
InvalidStateException(crate::error::InvalidStateException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for DeleteServiceError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
DeleteServiceErrorKind::InternalServiceErrorException(_inner) => _inner.fmt(f),
DeleteServiceErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
DeleteServiceErrorKind::InvalidStateException(_inner) => _inner.fmt(f),
DeleteServiceErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
DeleteServiceErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for DeleteServiceError {
fn code(&self) -> Option<&str> {
DeleteServiceError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl DeleteServiceError {
pub fn new(kind: DeleteServiceErrorKind, 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: DeleteServiceErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: DeleteServiceErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
DeleteServiceErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
DeleteServiceErrorKind::InvalidRequestException(_)
)
}
pub fn is_invalid_state_exception(&self) -> bool {
matches!(&self.kind, DeleteServiceErrorKind::InvalidStateException(_))
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
DeleteServiceErrorKind::ResourceNotFoundException(_)
)
}
}
impl std::error::Error for DeleteServiceError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
DeleteServiceErrorKind::InternalServiceErrorException(_inner) => Some(_inner),
DeleteServiceErrorKind::InvalidRequestException(_inner) => Some(_inner),
DeleteServiceErrorKind::InvalidStateException(_inner) => Some(_inner),
DeleteServiceErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
DeleteServiceErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DeleteObservabilityConfigurationError {
pub kind: DeleteObservabilityConfigurationErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for DeleteObservabilityConfigurationError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: DeleteObservabilityConfigurationErrorKind::Unhandled(
crate::error::Unhandled::new(source),
),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DeleteObservabilityConfigurationErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for DeleteObservabilityConfigurationError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
DeleteObservabilityConfigurationErrorKind::InternalServiceErrorException(_inner) => {
_inner.fmt(f)
}
DeleteObservabilityConfigurationErrorKind::InvalidRequestException(_inner) => {
_inner.fmt(f)
}
DeleteObservabilityConfigurationErrorKind::ResourceNotFoundException(_inner) => {
_inner.fmt(f)
}
DeleteObservabilityConfigurationErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for DeleteObservabilityConfigurationError {
fn code(&self) -> Option<&str> {
DeleteObservabilityConfigurationError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl DeleteObservabilityConfigurationError {
pub fn new(
kind: DeleteObservabilityConfigurationErrorKind,
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: DeleteObservabilityConfigurationErrorKind::Unhandled(
crate::error::Unhandled::new(err.into()),
),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: DeleteObservabilityConfigurationErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
DeleteObservabilityConfigurationErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
DeleteObservabilityConfigurationErrorKind::InvalidRequestException(_)
)
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
DeleteObservabilityConfigurationErrorKind::ResourceNotFoundException(_)
)
}
}
impl std::error::Error for DeleteObservabilityConfigurationError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
DeleteObservabilityConfigurationErrorKind::InternalServiceErrorException(_inner) => {
Some(_inner)
}
DeleteObservabilityConfigurationErrorKind::InvalidRequestException(_inner) => {
Some(_inner)
}
DeleteObservabilityConfigurationErrorKind::ResourceNotFoundException(_inner) => {
Some(_inner)
}
DeleteObservabilityConfigurationErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DeleteConnectionError {
pub kind: DeleteConnectionErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for DeleteConnectionError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: DeleteConnectionErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DeleteConnectionErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for DeleteConnectionError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
DeleteConnectionErrorKind::InternalServiceErrorException(_inner) => _inner.fmt(f),
DeleteConnectionErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
DeleteConnectionErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
DeleteConnectionErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for DeleteConnectionError {
fn code(&self) -> Option<&str> {
DeleteConnectionError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl DeleteConnectionError {
pub fn new(kind: DeleteConnectionErrorKind, 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: DeleteConnectionErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: DeleteConnectionErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
DeleteConnectionErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
DeleteConnectionErrorKind::InvalidRequestException(_)
)
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
DeleteConnectionErrorKind::ResourceNotFoundException(_)
)
}
}
impl std::error::Error for DeleteConnectionError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
DeleteConnectionErrorKind::InternalServiceErrorException(_inner) => Some(_inner),
DeleteConnectionErrorKind::InvalidRequestException(_inner) => Some(_inner),
DeleteConnectionErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
DeleteConnectionErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DeleteAutoScalingConfigurationError {
pub kind: DeleteAutoScalingConfigurationErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for DeleteAutoScalingConfigurationError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: DeleteAutoScalingConfigurationErrorKind::Unhandled(crate::error::Unhandled::new(
source,
)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DeleteAutoScalingConfigurationErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for DeleteAutoScalingConfigurationError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
DeleteAutoScalingConfigurationErrorKind::InternalServiceErrorException(_inner) => {
_inner.fmt(f)
}
DeleteAutoScalingConfigurationErrorKind::InvalidRequestException(_inner) => {
_inner.fmt(f)
}
DeleteAutoScalingConfigurationErrorKind::ResourceNotFoundException(_inner) => {
_inner.fmt(f)
}
DeleteAutoScalingConfigurationErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for DeleteAutoScalingConfigurationError {
fn code(&self) -> Option<&str> {
DeleteAutoScalingConfigurationError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl DeleteAutoScalingConfigurationError {
pub fn new(
kind: DeleteAutoScalingConfigurationErrorKind,
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: DeleteAutoScalingConfigurationErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: DeleteAutoScalingConfigurationErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
DeleteAutoScalingConfigurationErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
DeleteAutoScalingConfigurationErrorKind::InvalidRequestException(_)
)
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
DeleteAutoScalingConfigurationErrorKind::ResourceNotFoundException(_)
)
}
}
impl std::error::Error for DeleteAutoScalingConfigurationError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
DeleteAutoScalingConfigurationErrorKind::InternalServiceErrorException(_inner) => {
Some(_inner)
}
DeleteAutoScalingConfigurationErrorKind::InvalidRequestException(_inner) => {
Some(_inner)
}
DeleteAutoScalingConfigurationErrorKind::ResourceNotFoundException(_inner) => {
Some(_inner)
}
DeleteAutoScalingConfigurationErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct CreateVpcIngressConnectionError {
pub kind: CreateVpcIngressConnectionErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for CreateVpcIngressConnectionError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: CreateVpcIngressConnectionErrorKind::Unhandled(crate::error::Unhandled::new(
source,
)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum CreateVpcIngressConnectionErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
InvalidStateException(crate::error::InvalidStateException),
ServiceQuotaExceededException(crate::error::ServiceQuotaExceededException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for CreateVpcIngressConnectionError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
CreateVpcIngressConnectionErrorKind::InternalServiceErrorException(_inner) => {
_inner.fmt(f)
}
CreateVpcIngressConnectionErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
CreateVpcIngressConnectionErrorKind::InvalidStateException(_inner) => _inner.fmt(f),
CreateVpcIngressConnectionErrorKind::ServiceQuotaExceededException(_inner) => {
_inner.fmt(f)
}
CreateVpcIngressConnectionErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for CreateVpcIngressConnectionError {
fn code(&self) -> Option<&str> {
CreateVpcIngressConnectionError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl CreateVpcIngressConnectionError {
pub fn new(kind: CreateVpcIngressConnectionErrorKind, 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: CreateVpcIngressConnectionErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: CreateVpcIngressConnectionErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
CreateVpcIngressConnectionErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
CreateVpcIngressConnectionErrorKind::InvalidRequestException(_)
)
}
pub fn is_invalid_state_exception(&self) -> bool {
matches!(
&self.kind,
CreateVpcIngressConnectionErrorKind::InvalidStateException(_)
)
}
pub fn is_service_quota_exceeded_exception(&self) -> bool {
matches!(
&self.kind,
CreateVpcIngressConnectionErrorKind::ServiceQuotaExceededException(_)
)
}
}
impl std::error::Error for CreateVpcIngressConnectionError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
CreateVpcIngressConnectionErrorKind::InternalServiceErrorException(_inner) => {
Some(_inner)
}
CreateVpcIngressConnectionErrorKind::InvalidRequestException(_inner) => Some(_inner),
CreateVpcIngressConnectionErrorKind::InvalidStateException(_inner) => Some(_inner),
CreateVpcIngressConnectionErrorKind::ServiceQuotaExceededException(_inner) => {
Some(_inner)
}
CreateVpcIngressConnectionErrorKind::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_5) = &self.message {
{
write!(f, ": {}", inner_5)?;
}
}
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::fmt::Debug)]
pub struct CreateVpcConnectorError {
pub kind: CreateVpcConnectorErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for CreateVpcConnectorError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: CreateVpcConnectorErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum CreateVpcConnectorErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
ServiceQuotaExceededException(crate::error::ServiceQuotaExceededException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for CreateVpcConnectorError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
CreateVpcConnectorErrorKind::InternalServiceErrorException(_inner) => _inner.fmt(f),
CreateVpcConnectorErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
CreateVpcConnectorErrorKind::ServiceQuotaExceededException(_inner) => _inner.fmt(f),
CreateVpcConnectorErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for CreateVpcConnectorError {
fn code(&self) -> Option<&str> {
CreateVpcConnectorError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl CreateVpcConnectorError {
pub fn new(kind: CreateVpcConnectorErrorKind, 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: CreateVpcConnectorErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: CreateVpcConnectorErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
CreateVpcConnectorErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
CreateVpcConnectorErrorKind::InvalidRequestException(_)
)
}
pub fn is_service_quota_exceeded_exception(&self) -> bool {
matches!(
&self.kind,
CreateVpcConnectorErrorKind::ServiceQuotaExceededException(_)
)
}
}
impl std::error::Error for CreateVpcConnectorError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
CreateVpcConnectorErrorKind::InternalServiceErrorException(_inner) => Some(_inner),
CreateVpcConnectorErrorKind::InvalidRequestException(_inner) => Some(_inner),
CreateVpcConnectorErrorKind::ServiceQuotaExceededException(_inner) => Some(_inner),
CreateVpcConnectorErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct CreateServiceError {
pub kind: CreateServiceErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for CreateServiceError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: CreateServiceErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum CreateServiceErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
ServiceQuotaExceededException(crate::error::ServiceQuotaExceededException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for CreateServiceError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
CreateServiceErrorKind::InternalServiceErrorException(_inner) => _inner.fmt(f),
CreateServiceErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
CreateServiceErrorKind::ServiceQuotaExceededException(_inner) => _inner.fmt(f),
CreateServiceErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for CreateServiceError {
fn code(&self) -> Option<&str> {
CreateServiceError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl CreateServiceError {
pub fn new(kind: CreateServiceErrorKind, 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: CreateServiceErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: CreateServiceErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
CreateServiceErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
CreateServiceErrorKind::InvalidRequestException(_)
)
}
pub fn is_service_quota_exceeded_exception(&self) -> bool {
matches!(
&self.kind,
CreateServiceErrorKind::ServiceQuotaExceededException(_)
)
}
}
impl std::error::Error for CreateServiceError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
CreateServiceErrorKind::InternalServiceErrorException(_inner) => Some(_inner),
CreateServiceErrorKind::InvalidRequestException(_inner) => Some(_inner),
CreateServiceErrorKind::ServiceQuotaExceededException(_inner) => Some(_inner),
CreateServiceErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct CreateObservabilityConfigurationError {
pub kind: CreateObservabilityConfigurationErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for CreateObservabilityConfigurationError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: CreateObservabilityConfigurationErrorKind::Unhandled(
crate::error::Unhandled::new(source),
),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum CreateObservabilityConfigurationErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
ServiceQuotaExceededException(crate::error::ServiceQuotaExceededException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for CreateObservabilityConfigurationError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
CreateObservabilityConfigurationErrorKind::InternalServiceErrorException(_inner) => {
_inner.fmt(f)
}
CreateObservabilityConfigurationErrorKind::InvalidRequestException(_inner) => {
_inner.fmt(f)
}
CreateObservabilityConfigurationErrorKind::ServiceQuotaExceededException(_inner) => {
_inner.fmt(f)
}
CreateObservabilityConfigurationErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for CreateObservabilityConfigurationError {
fn code(&self) -> Option<&str> {
CreateObservabilityConfigurationError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl CreateObservabilityConfigurationError {
pub fn new(
kind: CreateObservabilityConfigurationErrorKind,
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: CreateObservabilityConfigurationErrorKind::Unhandled(
crate::error::Unhandled::new(err.into()),
),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: CreateObservabilityConfigurationErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
CreateObservabilityConfigurationErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
CreateObservabilityConfigurationErrorKind::InvalidRequestException(_)
)
}
pub fn is_service_quota_exceeded_exception(&self) -> bool {
matches!(
&self.kind,
CreateObservabilityConfigurationErrorKind::ServiceQuotaExceededException(_)
)
}
}
impl std::error::Error for CreateObservabilityConfigurationError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
CreateObservabilityConfigurationErrorKind::InternalServiceErrorException(_inner) => {
Some(_inner)
}
CreateObservabilityConfigurationErrorKind::InvalidRequestException(_inner) => {
Some(_inner)
}
CreateObservabilityConfigurationErrorKind::ServiceQuotaExceededException(_inner) => {
Some(_inner)
}
CreateObservabilityConfigurationErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct CreateConnectionError {
pub kind: CreateConnectionErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for CreateConnectionError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: CreateConnectionErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum CreateConnectionErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
ServiceQuotaExceededException(crate::error::ServiceQuotaExceededException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for CreateConnectionError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
CreateConnectionErrorKind::InternalServiceErrorException(_inner) => _inner.fmt(f),
CreateConnectionErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
CreateConnectionErrorKind::ServiceQuotaExceededException(_inner) => _inner.fmt(f),
CreateConnectionErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for CreateConnectionError {
fn code(&self) -> Option<&str> {
CreateConnectionError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl CreateConnectionError {
pub fn new(kind: CreateConnectionErrorKind, 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: CreateConnectionErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: CreateConnectionErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
CreateConnectionErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
CreateConnectionErrorKind::InvalidRequestException(_)
)
}
pub fn is_service_quota_exceeded_exception(&self) -> bool {
matches!(
&self.kind,
CreateConnectionErrorKind::ServiceQuotaExceededException(_)
)
}
}
impl std::error::Error for CreateConnectionError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
CreateConnectionErrorKind::InternalServiceErrorException(_inner) => Some(_inner),
CreateConnectionErrorKind::InvalidRequestException(_inner) => Some(_inner),
CreateConnectionErrorKind::ServiceQuotaExceededException(_inner) => Some(_inner),
CreateConnectionErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct CreateAutoScalingConfigurationError {
pub kind: CreateAutoScalingConfigurationErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for CreateAutoScalingConfigurationError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: CreateAutoScalingConfigurationErrorKind::Unhandled(crate::error::Unhandled::new(
source,
)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum CreateAutoScalingConfigurationErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
ServiceQuotaExceededException(crate::error::ServiceQuotaExceededException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for CreateAutoScalingConfigurationError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
CreateAutoScalingConfigurationErrorKind::InternalServiceErrorException(_inner) => {
_inner.fmt(f)
}
CreateAutoScalingConfigurationErrorKind::InvalidRequestException(_inner) => {
_inner.fmt(f)
}
CreateAutoScalingConfigurationErrorKind::ServiceQuotaExceededException(_inner) => {
_inner.fmt(f)
}
CreateAutoScalingConfigurationErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for CreateAutoScalingConfigurationError {
fn code(&self) -> Option<&str> {
CreateAutoScalingConfigurationError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl CreateAutoScalingConfigurationError {
pub fn new(
kind: CreateAutoScalingConfigurationErrorKind,
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: CreateAutoScalingConfigurationErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: CreateAutoScalingConfigurationErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
CreateAutoScalingConfigurationErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
CreateAutoScalingConfigurationErrorKind::InvalidRequestException(_)
)
}
pub fn is_service_quota_exceeded_exception(&self) -> bool {
matches!(
&self.kind,
CreateAutoScalingConfigurationErrorKind::ServiceQuotaExceededException(_)
)
}
}
impl std::error::Error for CreateAutoScalingConfigurationError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
CreateAutoScalingConfigurationErrorKind::InternalServiceErrorException(_inner) => {
Some(_inner)
}
CreateAutoScalingConfigurationErrorKind::InvalidRequestException(_inner) => {
Some(_inner)
}
CreateAutoScalingConfigurationErrorKind::ServiceQuotaExceededException(_inner) => {
Some(_inner)
}
CreateAutoScalingConfigurationErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct AssociateCustomDomainError {
pub kind: AssociateCustomDomainErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for AssociateCustomDomainError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: AssociateCustomDomainErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum AssociateCustomDomainErrorKind {
InternalServiceErrorException(crate::error::InternalServiceErrorException),
InvalidRequestException(crate::error::InvalidRequestException),
InvalidStateException(crate::error::InvalidStateException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for AssociateCustomDomainError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
AssociateCustomDomainErrorKind::InternalServiceErrorException(_inner) => _inner.fmt(f),
AssociateCustomDomainErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
AssociateCustomDomainErrorKind::InvalidStateException(_inner) => _inner.fmt(f),
AssociateCustomDomainErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for AssociateCustomDomainError {
fn code(&self) -> Option<&str> {
AssociateCustomDomainError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl AssociateCustomDomainError {
pub fn new(kind: AssociateCustomDomainErrorKind, 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: AssociateCustomDomainErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: AssociateCustomDomainErrorKind::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_internal_service_error_exception(&self) -> bool {
matches!(
&self.kind,
AssociateCustomDomainErrorKind::InternalServiceErrorException(_)
)
}
pub fn is_invalid_request_exception(&self) -> bool {
matches!(
&self.kind,
AssociateCustomDomainErrorKind::InvalidRequestException(_)
)
}
pub fn is_invalid_state_exception(&self) -> bool {
matches!(
&self.kind,
AssociateCustomDomainErrorKind::InvalidStateException(_)
)
}
}
impl std::error::Error for AssociateCustomDomainError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
AssociateCustomDomainErrorKind::InternalServiceErrorException(_inner) => Some(_inner),
AssociateCustomDomainErrorKind::InvalidRequestException(_inner) => Some(_inner),
AssociateCustomDomainErrorKind::InvalidStateException(_inner) => Some(_inner),
AssociateCustomDomainErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[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 _)
}
}