#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct UpdatePipelineStatusError {
pub kind: UpdatePipelineStatusErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for UpdatePipelineStatusError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: UpdatePipelineStatusErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum UpdatePipelineStatusErrorKind {
AccessDeniedException(crate::error::AccessDeniedException),
#[allow(missing_docs)] IncompatibleVersionException(crate::error::IncompatibleVersionException),
InternalServiceException(crate::error::InternalServiceException),
ResourceInUseException(crate::error::ResourceInUseException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
ValidationException(crate::error::ValidationException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for UpdatePipelineStatusError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
UpdatePipelineStatusErrorKind::AccessDeniedException(_inner) => _inner.fmt(f),
UpdatePipelineStatusErrorKind::IncompatibleVersionException(_inner) => _inner.fmt(f),
UpdatePipelineStatusErrorKind::InternalServiceException(_inner) => _inner.fmt(f),
UpdatePipelineStatusErrorKind::ResourceInUseException(_inner) => _inner.fmt(f),
UpdatePipelineStatusErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
UpdatePipelineStatusErrorKind::ValidationException(_inner) => _inner.fmt(f),
UpdatePipelineStatusErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for UpdatePipelineStatusError {
fn code(&self) -> Option<&str> {
UpdatePipelineStatusError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl UpdatePipelineStatusError {
pub fn new(kind: UpdatePipelineStatusErrorKind, 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: UpdatePipelineStatusErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: UpdatePipelineStatusErrorKind::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_access_denied_exception(&self) -> bool {
matches!(
&self.kind,
UpdatePipelineStatusErrorKind::AccessDeniedException(_)
)
}
pub fn is_incompatible_version_exception(&self) -> bool {
matches!(
&self.kind,
UpdatePipelineStatusErrorKind::IncompatibleVersionException(_)
)
}
pub fn is_internal_service_exception(&self) -> bool {
matches!(
&self.kind,
UpdatePipelineStatusErrorKind::InternalServiceException(_)
)
}
pub fn is_resource_in_use_exception(&self) -> bool {
matches!(
&self.kind,
UpdatePipelineStatusErrorKind::ResourceInUseException(_)
)
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
UpdatePipelineStatusErrorKind::ResourceNotFoundException(_)
)
}
pub fn is_validation_exception(&self) -> bool {
matches!(
&self.kind,
UpdatePipelineStatusErrorKind::ValidationException(_)
)
}
}
impl std::error::Error for UpdatePipelineStatusError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
UpdatePipelineStatusErrorKind::AccessDeniedException(_inner) => Some(_inner),
UpdatePipelineStatusErrorKind::IncompatibleVersionException(_inner) => Some(_inner),
UpdatePipelineStatusErrorKind::InternalServiceException(_inner) => Some(_inner),
UpdatePipelineStatusErrorKind::ResourceInUseException(_inner) => Some(_inner),
UpdatePipelineStatusErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
UpdatePipelineStatusErrorKind::ValidationException(_inner) => Some(_inner),
UpdatePipelineStatusErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ValidationException {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl ValidationException {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for ValidationException {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "ValidationException")?;
if let Some(inner_1) = &self.message {
{
write!(f, ": {}", inner_1)?;
}
}
Ok(())
}
}
impl std::error::Error for ValidationException {}
pub mod validation_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::ValidationException {
crate::error::ValidationException {
message: self.message,
}
}
}
}
impl ValidationException {
pub fn builder() -> crate::error::validation_exception::Builder {
crate::error::validation_exception::Builder::default()
}
}
#[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_2) = &self.message {
{
write!(f, ": {}", inner_2)?;
}
}
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 ResourceInUseException {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl ResourceInUseException {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for ResourceInUseException {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "ResourceInUseException")?;
if let Some(inner_3) = &self.message {
{
write!(f, ": {}", inner_3)?;
}
}
Ok(())
}
}
impl std::error::Error for ResourceInUseException {}
pub mod resource_in_use_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::ResourceInUseException {
crate::error::ResourceInUseException {
message: self.message,
}
}
}
}
impl ResourceInUseException {
pub fn builder() -> crate::error::resource_in_use_exception::Builder {
crate::error::resource_in_use_exception::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct InternalServiceException {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl InternalServiceException {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for InternalServiceException {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "InternalServiceException")?;
if let Some(inner_4) = &self.message {
{
write!(f, ": {}", inner_4)?;
}
}
Ok(())
}
}
impl std::error::Error for InternalServiceException {}
pub mod internal_service_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::InternalServiceException {
crate::error::InternalServiceException {
message: self.message,
}
}
}
}
impl InternalServiceException {
pub fn builder() -> crate::error::internal_service_exception::Builder {
crate::error::internal_service_exception::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct IncompatibleVersionException {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl IncompatibleVersionException {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for IncompatibleVersionException {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "IncompatibleVersionException")?;
if let Some(inner_5) = &self.message {
{
write!(f, ": {}", inner_5)?;
}
}
Ok(())
}
}
impl std::error::Error for IncompatibleVersionException {}
pub mod incompatible_version_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::IncompatibleVersionException {
crate::error::IncompatibleVersionException {
message: self.message,
}
}
}
}
impl IncompatibleVersionException {
pub fn builder() -> crate::error::incompatible_version_exception::Builder {
crate::error::incompatible_version_exception::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct AccessDeniedException {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl AccessDeniedException {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for AccessDeniedException {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "AccessDeniedException")?;
if let Some(inner_6) = &self.message {
{
write!(f, ": {}", inner_6)?;
}
}
Ok(())
}
}
impl std::error::Error for AccessDeniedException {}
pub mod access_denied_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::AccessDeniedException {
crate::error::AccessDeniedException {
message: self.message,
}
}
}
}
impl AccessDeniedException {
pub fn builder() -> crate::error::access_denied_exception::Builder {
crate::error::access_denied_exception::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct UpdatePipelineNotificationsError {
pub kind: UpdatePipelineNotificationsErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for UpdatePipelineNotificationsError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: UpdatePipelineNotificationsErrorKind::Unhandled(crate::error::Unhandled::new(
source,
)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum UpdatePipelineNotificationsErrorKind {
AccessDeniedException(crate::error::AccessDeniedException),
#[allow(missing_docs)] IncompatibleVersionException(crate::error::IncompatibleVersionException),
InternalServiceException(crate::error::InternalServiceException),
ResourceInUseException(crate::error::ResourceInUseException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
ValidationException(crate::error::ValidationException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for UpdatePipelineNotificationsError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
UpdatePipelineNotificationsErrorKind::AccessDeniedException(_inner) => _inner.fmt(f),
UpdatePipelineNotificationsErrorKind::IncompatibleVersionException(_inner) => {
_inner.fmt(f)
}
UpdatePipelineNotificationsErrorKind::InternalServiceException(_inner) => _inner.fmt(f),
UpdatePipelineNotificationsErrorKind::ResourceInUseException(_inner) => _inner.fmt(f),
UpdatePipelineNotificationsErrorKind::ResourceNotFoundException(_inner) => {
_inner.fmt(f)
}
UpdatePipelineNotificationsErrorKind::ValidationException(_inner) => _inner.fmt(f),
UpdatePipelineNotificationsErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for UpdatePipelineNotificationsError {
fn code(&self) -> Option<&str> {
UpdatePipelineNotificationsError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl UpdatePipelineNotificationsError {
pub fn new(kind: UpdatePipelineNotificationsErrorKind, 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: UpdatePipelineNotificationsErrorKind::Unhandled(crate::error::Unhandled::new(
err.into(),
)),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: UpdatePipelineNotificationsErrorKind::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_access_denied_exception(&self) -> bool {
matches!(
&self.kind,
UpdatePipelineNotificationsErrorKind::AccessDeniedException(_)
)
}
pub fn is_incompatible_version_exception(&self) -> bool {
matches!(
&self.kind,
UpdatePipelineNotificationsErrorKind::IncompatibleVersionException(_)
)
}
pub fn is_internal_service_exception(&self) -> bool {
matches!(
&self.kind,
UpdatePipelineNotificationsErrorKind::InternalServiceException(_)
)
}
pub fn is_resource_in_use_exception(&self) -> bool {
matches!(
&self.kind,
UpdatePipelineNotificationsErrorKind::ResourceInUseException(_)
)
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
UpdatePipelineNotificationsErrorKind::ResourceNotFoundException(_)
)
}
pub fn is_validation_exception(&self) -> bool {
matches!(
&self.kind,
UpdatePipelineNotificationsErrorKind::ValidationException(_)
)
}
}
impl std::error::Error for UpdatePipelineNotificationsError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
UpdatePipelineNotificationsErrorKind::AccessDeniedException(_inner) => Some(_inner),
UpdatePipelineNotificationsErrorKind::IncompatibleVersionException(_inner) => {
Some(_inner)
}
UpdatePipelineNotificationsErrorKind::InternalServiceException(_inner) => Some(_inner),
UpdatePipelineNotificationsErrorKind::ResourceInUseException(_inner) => Some(_inner),
UpdatePipelineNotificationsErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
UpdatePipelineNotificationsErrorKind::ValidationException(_inner) => Some(_inner),
UpdatePipelineNotificationsErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct UpdatePipelineError {
pub kind: UpdatePipelineErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for UpdatePipelineError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: UpdatePipelineErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum UpdatePipelineErrorKind {
AccessDeniedException(crate::error::AccessDeniedException),
#[allow(missing_docs)] IncompatibleVersionException(crate::error::IncompatibleVersionException),
InternalServiceException(crate::error::InternalServiceException),
ResourceInUseException(crate::error::ResourceInUseException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
ValidationException(crate::error::ValidationException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for UpdatePipelineError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
UpdatePipelineErrorKind::AccessDeniedException(_inner) => _inner.fmt(f),
UpdatePipelineErrorKind::IncompatibleVersionException(_inner) => _inner.fmt(f),
UpdatePipelineErrorKind::InternalServiceException(_inner) => _inner.fmt(f),
UpdatePipelineErrorKind::ResourceInUseException(_inner) => _inner.fmt(f),
UpdatePipelineErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
UpdatePipelineErrorKind::ValidationException(_inner) => _inner.fmt(f),
UpdatePipelineErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for UpdatePipelineError {
fn code(&self) -> Option<&str> {
UpdatePipelineError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl UpdatePipelineError {
pub fn new(kind: UpdatePipelineErrorKind, 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: UpdatePipelineErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: UpdatePipelineErrorKind::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_access_denied_exception(&self) -> bool {
matches!(
&self.kind,
UpdatePipelineErrorKind::AccessDeniedException(_)
)
}
pub fn is_incompatible_version_exception(&self) -> bool {
matches!(
&self.kind,
UpdatePipelineErrorKind::IncompatibleVersionException(_)
)
}
pub fn is_internal_service_exception(&self) -> bool {
matches!(
&self.kind,
UpdatePipelineErrorKind::InternalServiceException(_)
)
}
pub fn is_resource_in_use_exception(&self) -> bool {
matches!(
&self.kind,
UpdatePipelineErrorKind::ResourceInUseException(_)
)
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
UpdatePipelineErrorKind::ResourceNotFoundException(_)
)
}
pub fn is_validation_exception(&self) -> bool {
matches!(&self.kind, UpdatePipelineErrorKind::ValidationException(_))
}
}
impl std::error::Error for UpdatePipelineError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
UpdatePipelineErrorKind::AccessDeniedException(_inner) => Some(_inner),
UpdatePipelineErrorKind::IncompatibleVersionException(_inner) => Some(_inner),
UpdatePipelineErrorKind::InternalServiceException(_inner) => Some(_inner),
UpdatePipelineErrorKind::ResourceInUseException(_inner) => Some(_inner),
UpdatePipelineErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
UpdatePipelineErrorKind::ValidationException(_inner) => Some(_inner),
UpdatePipelineErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct TestRoleError {
pub kind: TestRoleErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for TestRoleError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: TestRoleErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum TestRoleErrorKind {
AccessDeniedException(crate::error::AccessDeniedException),
#[allow(missing_docs)] IncompatibleVersionException(crate::error::IncompatibleVersionException),
InternalServiceException(crate::error::InternalServiceException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
ValidationException(crate::error::ValidationException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for TestRoleError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
TestRoleErrorKind::AccessDeniedException(_inner) => _inner.fmt(f),
TestRoleErrorKind::IncompatibleVersionException(_inner) => _inner.fmt(f),
TestRoleErrorKind::InternalServiceException(_inner) => _inner.fmt(f),
TestRoleErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
TestRoleErrorKind::ValidationException(_inner) => _inner.fmt(f),
TestRoleErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for TestRoleError {
fn code(&self) -> Option<&str> {
TestRoleError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl TestRoleError {
pub fn new(kind: TestRoleErrorKind, 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: TestRoleErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: TestRoleErrorKind::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_access_denied_exception(&self) -> bool {
matches!(&self.kind, TestRoleErrorKind::AccessDeniedException(_))
}
pub fn is_incompatible_version_exception(&self) -> bool {
matches!(
&self.kind,
TestRoleErrorKind::IncompatibleVersionException(_)
)
}
pub fn is_internal_service_exception(&self) -> bool {
matches!(&self.kind, TestRoleErrorKind::InternalServiceException(_))
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(&self.kind, TestRoleErrorKind::ResourceNotFoundException(_))
}
pub fn is_validation_exception(&self) -> bool {
matches!(&self.kind, TestRoleErrorKind::ValidationException(_))
}
}
impl std::error::Error for TestRoleError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
TestRoleErrorKind::AccessDeniedException(_inner) => Some(_inner),
TestRoleErrorKind::IncompatibleVersionException(_inner) => Some(_inner),
TestRoleErrorKind::InternalServiceException(_inner) => Some(_inner),
TestRoleErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
TestRoleErrorKind::ValidationException(_inner) => Some(_inner),
TestRoleErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ReadPresetError {
pub kind: ReadPresetErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for ReadPresetError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: ReadPresetErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ReadPresetErrorKind {
AccessDeniedException(crate::error::AccessDeniedException),
#[allow(missing_docs)] IncompatibleVersionException(crate::error::IncompatibleVersionException),
InternalServiceException(crate::error::InternalServiceException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
ValidationException(crate::error::ValidationException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for ReadPresetError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
ReadPresetErrorKind::AccessDeniedException(_inner) => _inner.fmt(f),
ReadPresetErrorKind::IncompatibleVersionException(_inner) => _inner.fmt(f),
ReadPresetErrorKind::InternalServiceException(_inner) => _inner.fmt(f),
ReadPresetErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
ReadPresetErrorKind::ValidationException(_inner) => _inner.fmt(f),
ReadPresetErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for ReadPresetError {
fn code(&self) -> Option<&str> {
ReadPresetError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl ReadPresetError {
pub fn new(kind: ReadPresetErrorKind, 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: ReadPresetErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: ReadPresetErrorKind::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_access_denied_exception(&self) -> bool {
matches!(&self.kind, ReadPresetErrorKind::AccessDeniedException(_))
}
pub fn is_incompatible_version_exception(&self) -> bool {
matches!(
&self.kind,
ReadPresetErrorKind::IncompatibleVersionException(_)
)
}
pub fn is_internal_service_exception(&self) -> bool {
matches!(&self.kind, ReadPresetErrorKind::InternalServiceException(_))
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
ReadPresetErrorKind::ResourceNotFoundException(_)
)
}
pub fn is_validation_exception(&self) -> bool {
matches!(&self.kind, ReadPresetErrorKind::ValidationException(_))
}
}
impl std::error::Error for ReadPresetError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
ReadPresetErrorKind::AccessDeniedException(_inner) => Some(_inner),
ReadPresetErrorKind::IncompatibleVersionException(_inner) => Some(_inner),
ReadPresetErrorKind::InternalServiceException(_inner) => Some(_inner),
ReadPresetErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
ReadPresetErrorKind::ValidationException(_inner) => Some(_inner),
ReadPresetErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ReadPipelineError {
pub kind: ReadPipelineErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for ReadPipelineError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: ReadPipelineErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ReadPipelineErrorKind {
AccessDeniedException(crate::error::AccessDeniedException),
#[allow(missing_docs)] IncompatibleVersionException(crate::error::IncompatibleVersionException),
InternalServiceException(crate::error::InternalServiceException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
ValidationException(crate::error::ValidationException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for ReadPipelineError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
ReadPipelineErrorKind::AccessDeniedException(_inner) => _inner.fmt(f),
ReadPipelineErrorKind::IncompatibleVersionException(_inner) => _inner.fmt(f),
ReadPipelineErrorKind::InternalServiceException(_inner) => _inner.fmt(f),
ReadPipelineErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
ReadPipelineErrorKind::ValidationException(_inner) => _inner.fmt(f),
ReadPipelineErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for ReadPipelineError {
fn code(&self) -> Option<&str> {
ReadPipelineError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl ReadPipelineError {
pub fn new(kind: ReadPipelineErrorKind, 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: ReadPipelineErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: ReadPipelineErrorKind::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_access_denied_exception(&self) -> bool {
matches!(&self.kind, ReadPipelineErrorKind::AccessDeniedException(_))
}
pub fn is_incompatible_version_exception(&self) -> bool {
matches!(
&self.kind,
ReadPipelineErrorKind::IncompatibleVersionException(_)
)
}
pub fn is_internal_service_exception(&self) -> bool {
matches!(
&self.kind,
ReadPipelineErrorKind::InternalServiceException(_)
)
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
ReadPipelineErrorKind::ResourceNotFoundException(_)
)
}
pub fn is_validation_exception(&self) -> bool {
matches!(&self.kind, ReadPipelineErrorKind::ValidationException(_))
}
}
impl std::error::Error for ReadPipelineError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
ReadPipelineErrorKind::AccessDeniedException(_inner) => Some(_inner),
ReadPipelineErrorKind::IncompatibleVersionException(_inner) => Some(_inner),
ReadPipelineErrorKind::InternalServiceException(_inner) => Some(_inner),
ReadPipelineErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
ReadPipelineErrorKind::ValidationException(_inner) => Some(_inner),
ReadPipelineErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ReadJobError {
pub kind: ReadJobErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for ReadJobError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: ReadJobErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ReadJobErrorKind {
AccessDeniedException(crate::error::AccessDeniedException),
#[allow(missing_docs)] IncompatibleVersionException(crate::error::IncompatibleVersionException),
InternalServiceException(crate::error::InternalServiceException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
ValidationException(crate::error::ValidationException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for ReadJobError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
ReadJobErrorKind::AccessDeniedException(_inner) => _inner.fmt(f),
ReadJobErrorKind::IncompatibleVersionException(_inner) => _inner.fmt(f),
ReadJobErrorKind::InternalServiceException(_inner) => _inner.fmt(f),
ReadJobErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
ReadJobErrorKind::ValidationException(_inner) => _inner.fmt(f),
ReadJobErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for ReadJobError {
fn code(&self) -> Option<&str> {
ReadJobError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl ReadJobError {
pub fn new(kind: ReadJobErrorKind, 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: ReadJobErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: ReadJobErrorKind::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_access_denied_exception(&self) -> bool {
matches!(&self.kind, ReadJobErrorKind::AccessDeniedException(_))
}
pub fn is_incompatible_version_exception(&self) -> bool {
matches!(
&self.kind,
ReadJobErrorKind::IncompatibleVersionException(_)
)
}
pub fn is_internal_service_exception(&self) -> bool {
matches!(&self.kind, ReadJobErrorKind::InternalServiceException(_))
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(&self.kind, ReadJobErrorKind::ResourceNotFoundException(_))
}
pub fn is_validation_exception(&self) -> bool {
matches!(&self.kind, ReadJobErrorKind::ValidationException(_))
}
}
impl std::error::Error for ReadJobError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
ReadJobErrorKind::AccessDeniedException(_inner) => Some(_inner),
ReadJobErrorKind::IncompatibleVersionException(_inner) => Some(_inner),
ReadJobErrorKind::InternalServiceException(_inner) => Some(_inner),
ReadJobErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
ReadJobErrorKind::ValidationException(_inner) => Some(_inner),
ReadJobErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListPresetsError {
pub kind: ListPresetsErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for ListPresetsError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: ListPresetsErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListPresetsErrorKind {
AccessDeniedException(crate::error::AccessDeniedException),
#[allow(missing_docs)] IncompatibleVersionException(crate::error::IncompatibleVersionException),
InternalServiceException(crate::error::InternalServiceException),
ValidationException(crate::error::ValidationException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for ListPresetsError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
ListPresetsErrorKind::AccessDeniedException(_inner) => _inner.fmt(f),
ListPresetsErrorKind::IncompatibleVersionException(_inner) => _inner.fmt(f),
ListPresetsErrorKind::InternalServiceException(_inner) => _inner.fmt(f),
ListPresetsErrorKind::ValidationException(_inner) => _inner.fmt(f),
ListPresetsErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for ListPresetsError {
fn code(&self) -> Option<&str> {
ListPresetsError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl ListPresetsError {
pub fn new(kind: ListPresetsErrorKind, 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: ListPresetsErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: ListPresetsErrorKind::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_access_denied_exception(&self) -> bool {
matches!(&self.kind, ListPresetsErrorKind::AccessDeniedException(_))
}
pub fn is_incompatible_version_exception(&self) -> bool {
matches!(
&self.kind,
ListPresetsErrorKind::IncompatibleVersionException(_)
)
}
pub fn is_internal_service_exception(&self) -> bool {
matches!(
&self.kind,
ListPresetsErrorKind::InternalServiceException(_)
)
}
pub fn is_validation_exception(&self) -> bool {
matches!(&self.kind, ListPresetsErrorKind::ValidationException(_))
}
}
impl std::error::Error for ListPresetsError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
ListPresetsErrorKind::AccessDeniedException(_inner) => Some(_inner),
ListPresetsErrorKind::IncompatibleVersionException(_inner) => Some(_inner),
ListPresetsErrorKind::InternalServiceException(_inner) => Some(_inner),
ListPresetsErrorKind::ValidationException(_inner) => Some(_inner),
ListPresetsErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListPipelinesError {
pub kind: ListPipelinesErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for ListPipelinesError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: ListPipelinesErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListPipelinesErrorKind {
AccessDeniedException(crate::error::AccessDeniedException),
#[allow(missing_docs)] IncompatibleVersionException(crate::error::IncompatibleVersionException),
InternalServiceException(crate::error::InternalServiceException),
ValidationException(crate::error::ValidationException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for ListPipelinesError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
ListPipelinesErrorKind::AccessDeniedException(_inner) => _inner.fmt(f),
ListPipelinesErrorKind::IncompatibleVersionException(_inner) => _inner.fmt(f),
ListPipelinesErrorKind::InternalServiceException(_inner) => _inner.fmt(f),
ListPipelinesErrorKind::ValidationException(_inner) => _inner.fmt(f),
ListPipelinesErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for ListPipelinesError {
fn code(&self) -> Option<&str> {
ListPipelinesError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl ListPipelinesError {
pub fn new(kind: ListPipelinesErrorKind, 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: ListPipelinesErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: ListPipelinesErrorKind::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_access_denied_exception(&self) -> bool {
matches!(&self.kind, ListPipelinesErrorKind::AccessDeniedException(_))
}
pub fn is_incompatible_version_exception(&self) -> bool {
matches!(
&self.kind,
ListPipelinesErrorKind::IncompatibleVersionException(_)
)
}
pub fn is_internal_service_exception(&self) -> bool {
matches!(
&self.kind,
ListPipelinesErrorKind::InternalServiceException(_)
)
}
pub fn is_validation_exception(&self) -> bool {
matches!(&self.kind, ListPipelinesErrorKind::ValidationException(_))
}
}
impl std::error::Error for ListPipelinesError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
ListPipelinesErrorKind::AccessDeniedException(_inner) => Some(_inner),
ListPipelinesErrorKind::IncompatibleVersionException(_inner) => Some(_inner),
ListPipelinesErrorKind::InternalServiceException(_inner) => Some(_inner),
ListPipelinesErrorKind::ValidationException(_inner) => Some(_inner),
ListPipelinesErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListJobsByStatusError {
pub kind: ListJobsByStatusErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for ListJobsByStatusError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: ListJobsByStatusErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListJobsByStatusErrorKind {
AccessDeniedException(crate::error::AccessDeniedException),
#[allow(missing_docs)] IncompatibleVersionException(crate::error::IncompatibleVersionException),
InternalServiceException(crate::error::InternalServiceException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
ValidationException(crate::error::ValidationException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for ListJobsByStatusError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
ListJobsByStatusErrorKind::AccessDeniedException(_inner) => _inner.fmt(f),
ListJobsByStatusErrorKind::IncompatibleVersionException(_inner) => _inner.fmt(f),
ListJobsByStatusErrorKind::InternalServiceException(_inner) => _inner.fmt(f),
ListJobsByStatusErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
ListJobsByStatusErrorKind::ValidationException(_inner) => _inner.fmt(f),
ListJobsByStatusErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for ListJobsByStatusError {
fn code(&self) -> Option<&str> {
ListJobsByStatusError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl ListJobsByStatusError {
pub fn new(kind: ListJobsByStatusErrorKind, 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: ListJobsByStatusErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: ListJobsByStatusErrorKind::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_access_denied_exception(&self) -> bool {
matches!(
&self.kind,
ListJobsByStatusErrorKind::AccessDeniedException(_)
)
}
pub fn is_incompatible_version_exception(&self) -> bool {
matches!(
&self.kind,
ListJobsByStatusErrorKind::IncompatibleVersionException(_)
)
}
pub fn is_internal_service_exception(&self) -> bool {
matches!(
&self.kind,
ListJobsByStatusErrorKind::InternalServiceException(_)
)
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
ListJobsByStatusErrorKind::ResourceNotFoundException(_)
)
}
pub fn is_validation_exception(&self) -> bool {
matches!(
&self.kind,
ListJobsByStatusErrorKind::ValidationException(_)
)
}
}
impl std::error::Error for ListJobsByStatusError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
ListJobsByStatusErrorKind::AccessDeniedException(_inner) => Some(_inner),
ListJobsByStatusErrorKind::IncompatibleVersionException(_inner) => Some(_inner),
ListJobsByStatusErrorKind::InternalServiceException(_inner) => Some(_inner),
ListJobsByStatusErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
ListJobsByStatusErrorKind::ValidationException(_inner) => Some(_inner),
ListJobsByStatusErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListJobsByPipelineError {
pub kind: ListJobsByPipelineErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for ListJobsByPipelineError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: ListJobsByPipelineErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListJobsByPipelineErrorKind {
AccessDeniedException(crate::error::AccessDeniedException),
#[allow(missing_docs)] IncompatibleVersionException(crate::error::IncompatibleVersionException),
InternalServiceException(crate::error::InternalServiceException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
ValidationException(crate::error::ValidationException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for ListJobsByPipelineError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
ListJobsByPipelineErrorKind::AccessDeniedException(_inner) => _inner.fmt(f),
ListJobsByPipelineErrorKind::IncompatibleVersionException(_inner) => _inner.fmt(f),
ListJobsByPipelineErrorKind::InternalServiceException(_inner) => _inner.fmt(f),
ListJobsByPipelineErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
ListJobsByPipelineErrorKind::ValidationException(_inner) => _inner.fmt(f),
ListJobsByPipelineErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for ListJobsByPipelineError {
fn code(&self) -> Option<&str> {
ListJobsByPipelineError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl ListJobsByPipelineError {
pub fn new(kind: ListJobsByPipelineErrorKind, 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: ListJobsByPipelineErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: ListJobsByPipelineErrorKind::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_access_denied_exception(&self) -> bool {
matches!(
&self.kind,
ListJobsByPipelineErrorKind::AccessDeniedException(_)
)
}
pub fn is_incompatible_version_exception(&self) -> bool {
matches!(
&self.kind,
ListJobsByPipelineErrorKind::IncompatibleVersionException(_)
)
}
pub fn is_internal_service_exception(&self) -> bool {
matches!(
&self.kind,
ListJobsByPipelineErrorKind::InternalServiceException(_)
)
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
ListJobsByPipelineErrorKind::ResourceNotFoundException(_)
)
}
pub fn is_validation_exception(&self) -> bool {
matches!(
&self.kind,
ListJobsByPipelineErrorKind::ValidationException(_)
)
}
}
impl std::error::Error for ListJobsByPipelineError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
ListJobsByPipelineErrorKind::AccessDeniedException(_inner) => Some(_inner),
ListJobsByPipelineErrorKind::IncompatibleVersionException(_inner) => Some(_inner),
ListJobsByPipelineErrorKind::InternalServiceException(_inner) => Some(_inner),
ListJobsByPipelineErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
ListJobsByPipelineErrorKind::ValidationException(_inner) => Some(_inner),
ListJobsByPipelineErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DeletePresetError {
pub kind: DeletePresetErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for DeletePresetError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: DeletePresetErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DeletePresetErrorKind {
AccessDeniedException(crate::error::AccessDeniedException),
#[allow(missing_docs)] IncompatibleVersionException(crate::error::IncompatibleVersionException),
InternalServiceException(crate::error::InternalServiceException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
ValidationException(crate::error::ValidationException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for DeletePresetError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
DeletePresetErrorKind::AccessDeniedException(_inner) => _inner.fmt(f),
DeletePresetErrorKind::IncompatibleVersionException(_inner) => _inner.fmt(f),
DeletePresetErrorKind::InternalServiceException(_inner) => _inner.fmt(f),
DeletePresetErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
DeletePresetErrorKind::ValidationException(_inner) => _inner.fmt(f),
DeletePresetErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for DeletePresetError {
fn code(&self) -> Option<&str> {
DeletePresetError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl DeletePresetError {
pub fn new(kind: DeletePresetErrorKind, 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: DeletePresetErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: DeletePresetErrorKind::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_access_denied_exception(&self) -> bool {
matches!(&self.kind, DeletePresetErrorKind::AccessDeniedException(_))
}
pub fn is_incompatible_version_exception(&self) -> bool {
matches!(
&self.kind,
DeletePresetErrorKind::IncompatibleVersionException(_)
)
}
pub fn is_internal_service_exception(&self) -> bool {
matches!(
&self.kind,
DeletePresetErrorKind::InternalServiceException(_)
)
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
DeletePresetErrorKind::ResourceNotFoundException(_)
)
}
pub fn is_validation_exception(&self) -> bool {
matches!(&self.kind, DeletePresetErrorKind::ValidationException(_))
}
}
impl std::error::Error for DeletePresetError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
DeletePresetErrorKind::AccessDeniedException(_inner) => Some(_inner),
DeletePresetErrorKind::IncompatibleVersionException(_inner) => Some(_inner),
DeletePresetErrorKind::InternalServiceException(_inner) => Some(_inner),
DeletePresetErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
DeletePresetErrorKind::ValidationException(_inner) => Some(_inner),
DeletePresetErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DeletePipelineError {
pub kind: DeletePipelineErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for DeletePipelineError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: DeletePipelineErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DeletePipelineErrorKind {
AccessDeniedException(crate::error::AccessDeniedException),
#[allow(missing_docs)] IncompatibleVersionException(crate::error::IncompatibleVersionException),
InternalServiceException(crate::error::InternalServiceException),
ResourceInUseException(crate::error::ResourceInUseException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
ValidationException(crate::error::ValidationException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for DeletePipelineError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
DeletePipelineErrorKind::AccessDeniedException(_inner) => _inner.fmt(f),
DeletePipelineErrorKind::IncompatibleVersionException(_inner) => _inner.fmt(f),
DeletePipelineErrorKind::InternalServiceException(_inner) => _inner.fmt(f),
DeletePipelineErrorKind::ResourceInUseException(_inner) => _inner.fmt(f),
DeletePipelineErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
DeletePipelineErrorKind::ValidationException(_inner) => _inner.fmt(f),
DeletePipelineErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for DeletePipelineError {
fn code(&self) -> Option<&str> {
DeletePipelineError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl DeletePipelineError {
pub fn new(kind: DeletePipelineErrorKind, 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: DeletePipelineErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: DeletePipelineErrorKind::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_access_denied_exception(&self) -> bool {
matches!(
&self.kind,
DeletePipelineErrorKind::AccessDeniedException(_)
)
}
pub fn is_incompatible_version_exception(&self) -> bool {
matches!(
&self.kind,
DeletePipelineErrorKind::IncompatibleVersionException(_)
)
}
pub fn is_internal_service_exception(&self) -> bool {
matches!(
&self.kind,
DeletePipelineErrorKind::InternalServiceException(_)
)
}
pub fn is_resource_in_use_exception(&self) -> bool {
matches!(
&self.kind,
DeletePipelineErrorKind::ResourceInUseException(_)
)
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
DeletePipelineErrorKind::ResourceNotFoundException(_)
)
}
pub fn is_validation_exception(&self) -> bool {
matches!(&self.kind, DeletePipelineErrorKind::ValidationException(_))
}
}
impl std::error::Error for DeletePipelineError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
DeletePipelineErrorKind::AccessDeniedException(_inner) => Some(_inner),
DeletePipelineErrorKind::IncompatibleVersionException(_inner) => Some(_inner),
DeletePipelineErrorKind::InternalServiceException(_inner) => Some(_inner),
DeletePipelineErrorKind::ResourceInUseException(_inner) => Some(_inner),
DeletePipelineErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
DeletePipelineErrorKind::ValidationException(_inner) => Some(_inner),
DeletePipelineErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct CreatePresetError {
pub kind: CreatePresetErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for CreatePresetError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: CreatePresetErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum CreatePresetErrorKind {
AccessDeniedException(crate::error::AccessDeniedException),
#[allow(missing_docs)] IncompatibleVersionException(crate::error::IncompatibleVersionException),
InternalServiceException(crate::error::InternalServiceException),
LimitExceededException(crate::error::LimitExceededException),
ValidationException(crate::error::ValidationException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for CreatePresetError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
CreatePresetErrorKind::AccessDeniedException(_inner) => _inner.fmt(f),
CreatePresetErrorKind::IncompatibleVersionException(_inner) => _inner.fmt(f),
CreatePresetErrorKind::InternalServiceException(_inner) => _inner.fmt(f),
CreatePresetErrorKind::LimitExceededException(_inner) => _inner.fmt(f),
CreatePresetErrorKind::ValidationException(_inner) => _inner.fmt(f),
CreatePresetErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for CreatePresetError {
fn code(&self) -> Option<&str> {
CreatePresetError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl CreatePresetError {
pub fn new(kind: CreatePresetErrorKind, 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: CreatePresetErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: CreatePresetErrorKind::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_access_denied_exception(&self) -> bool {
matches!(&self.kind, CreatePresetErrorKind::AccessDeniedException(_))
}
pub fn is_incompatible_version_exception(&self) -> bool {
matches!(
&self.kind,
CreatePresetErrorKind::IncompatibleVersionException(_)
)
}
pub fn is_internal_service_exception(&self) -> bool {
matches!(
&self.kind,
CreatePresetErrorKind::InternalServiceException(_)
)
}
pub fn is_limit_exceeded_exception(&self) -> bool {
matches!(&self.kind, CreatePresetErrorKind::LimitExceededException(_))
}
pub fn is_validation_exception(&self) -> bool {
matches!(&self.kind, CreatePresetErrorKind::ValidationException(_))
}
}
impl std::error::Error for CreatePresetError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
CreatePresetErrorKind::AccessDeniedException(_inner) => Some(_inner),
CreatePresetErrorKind::IncompatibleVersionException(_inner) => Some(_inner),
CreatePresetErrorKind::InternalServiceException(_inner) => Some(_inner),
CreatePresetErrorKind::LimitExceededException(_inner) => Some(_inner),
CreatePresetErrorKind::ValidationException(_inner) => Some(_inner),
CreatePresetErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct LimitExceededException {
#[allow(missing_docs)] #[doc(hidden)]
pub message: std::option::Option<std::string::String>,
}
impl LimitExceededException {
pub fn message(&self) -> std::option::Option<&str> {
self.message.as_deref()
}
}
impl std::fmt::Display for LimitExceededException {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "LimitExceededException")?;
if let Some(inner_7) = &self.message {
{
write!(f, ": {}", inner_7)?;
}
}
Ok(())
}
}
impl std::error::Error for LimitExceededException {}
pub mod limit_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::LimitExceededException {
crate::error::LimitExceededException {
message: self.message,
}
}
}
}
impl LimitExceededException {
pub fn builder() -> crate::error::limit_exceeded_exception::Builder {
crate::error::limit_exceeded_exception::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct CreatePipelineError {
pub kind: CreatePipelineErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for CreatePipelineError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: CreatePipelineErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum CreatePipelineErrorKind {
AccessDeniedException(crate::error::AccessDeniedException),
#[allow(missing_docs)] IncompatibleVersionException(crate::error::IncompatibleVersionException),
InternalServiceException(crate::error::InternalServiceException),
LimitExceededException(crate::error::LimitExceededException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
ValidationException(crate::error::ValidationException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for CreatePipelineError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
CreatePipelineErrorKind::AccessDeniedException(_inner) => _inner.fmt(f),
CreatePipelineErrorKind::IncompatibleVersionException(_inner) => _inner.fmt(f),
CreatePipelineErrorKind::InternalServiceException(_inner) => _inner.fmt(f),
CreatePipelineErrorKind::LimitExceededException(_inner) => _inner.fmt(f),
CreatePipelineErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
CreatePipelineErrorKind::ValidationException(_inner) => _inner.fmt(f),
CreatePipelineErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for CreatePipelineError {
fn code(&self) -> Option<&str> {
CreatePipelineError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl CreatePipelineError {
pub fn new(kind: CreatePipelineErrorKind, 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: CreatePipelineErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: CreatePipelineErrorKind::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_access_denied_exception(&self) -> bool {
matches!(
&self.kind,
CreatePipelineErrorKind::AccessDeniedException(_)
)
}
pub fn is_incompatible_version_exception(&self) -> bool {
matches!(
&self.kind,
CreatePipelineErrorKind::IncompatibleVersionException(_)
)
}
pub fn is_internal_service_exception(&self) -> bool {
matches!(
&self.kind,
CreatePipelineErrorKind::InternalServiceException(_)
)
}
pub fn is_limit_exceeded_exception(&self) -> bool {
matches!(
&self.kind,
CreatePipelineErrorKind::LimitExceededException(_)
)
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(
&self.kind,
CreatePipelineErrorKind::ResourceNotFoundException(_)
)
}
pub fn is_validation_exception(&self) -> bool {
matches!(&self.kind, CreatePipelineErrorKind::ValidationException(_))
}
}
impl std::error::Error for CreatePipelineError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
CreatePipelineErrorKind::AccessDeniedException(_inner) => Some(_inner),
CreatePipelineErrorKind::IncompatibleVersionException(_inner) => Some(_inner),
CreatePipelineErrorKind::InternalServiceException(_inner) => Some(_inner),
CreatePipelineErrorKind::LimitExceededException(_inner) => Some(_inner),
CreatePipelineErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
CreatePipelineErrorKind::ValidationException(_inner) => Some(_inner),
CreatePipelineErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct CreateJobError {
pub kind: CreateJobErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for CreateJobError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: CreateJobErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum CreateJobErrorKind {
AccessDeniedException(crate::error::AccessDeniedException),
#[allow(missing_docs)] IncompatibleVersionException(crate::error::IncompatibleVersionException),
InternalServiceException(crate::error::InternalServiceException),
LimitExceededException(crate::error::LimitExceededException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
ValidationException(crate::error::ValidationException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for CreateJobError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
CreateJobErrorKind::AccessDeniedException(_inner) => _inner.fmt(f),
CreateJobErrorKind::IncompatibleVersionException(_inner) => _inner.fmt(f),
CreateJobErrorKind::InternalServiceException(_inner) => _inner.fmt(f),
CreateJobErrorKind::LimitExceededException(_inner) => _inner.fmt(f),
CreateJobErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
CreateJobErrorKind::ValidationException(_inner) => _inner.fmt(f),
CreateJobErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for CreateJobError {
fn code(&self) -> Option<&str> {
CreateJobError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl CreateJobError {
pub fn new(kind: CreateJobErrorKind, 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: CreateJobErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: CreateJobErrorKind::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_access_denied_exception(&self) -> bool {
matches!(&self.kind, CreateJobErrorKind::AccessDeniedException(_))
}
pub fn is_incompatible_version_exception(&self) -> bool {
matches!(
&self.kind,
CreateJobErrorKind::IncompatibleVersionException(_)
)
}
pub fn is_internal_service_exception(&self) -> bool {
matches!(&self.kind, CreateJobErrorKind::InternalServiceException(_))
}
pub fn is_limit_exceeded_exception(&self) -> bool {
matches!(&self.kind, CreateJobErrorKind::LimitExceededException(_))
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(&self.kind, CreateJobErrorKind::ResourceNotFoundException(_))
}
pub fn is_validation_exception(&self) -> bool {
matches!(&self.kind, CreateJobErrorKind::ValidationException(_))
}
}
impl std::error::Error for CreateJobError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
CreateJobErrorKind::AccessDeniedException(_inner) => Some(_inner),
CreateJobErrorKind::IncompatibleVersionException(_inner) => Some(_inner),
CreateJobErrorKind::InternalServiceException(_inner) => Some(_inner),
CreateJobErrorKind::LimitExceededException(_inner) => Some(_inner),
CreateJobErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
CreateJobErrorKind::ValidationException(_inner) => Some(_inner),
CreateJobErrorKind::Unhandled(_inner) => Some(_inner),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct CancelJobError {
pub kind: CancelJobErrorKind,
pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for CancelJobError {
fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
Self {
kind: CancelJobErrorKind::Unhandled(crate::error::Unhandled::new(source)),
meta: Default::default(),
}
}
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum CancelJobErrorKind {
AccessDeniedException(crate::error::AccessDeniedException),
#[allow(missing_docs)] IncompatibleVersionException(crate::error::IncompatibleVersionException),
InternalServiceException(crate::error::InternalServiceException),
ResourceInUseException(crate::error::ResourceInUseException),
ResourceNotFoundException(crate::error::ResourceNotFoundException),
ValidationException(crate::error::ValidationException),
Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for CancelJobError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.kind {
CancelJobErrorKind::AccessDeniedException(_inner) => _inner.fmt(f),
CancelJobErrorKind::IncompatibleVersionException(_inner) => _inner.fmt(f),
CancelJobErrorKind::InternalServiceException(_inner) => _inner.fmt(f),
CancelJobErrorKind::ResourceInUseException(_inner) => _inner.fmt(f),
CancelJobErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
CancelJobErrorKind::ValidationException(_inner) => _inner.fmt(f),
CancelJobErrorKind::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl aws_smithy_types::retry::ProvideErrorKind for CancelJobError {
fn code(&self) -> Option<&str> {
CancelJobError::code(self)
}
fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
None
}
}
impl CancelJobError {
pub fn new(kind: CancelJobErrorKind, 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: CancelJobErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
meta: Default::default(),
}
}
pub fn generic(err: aws_smithy_types::Error) -> Self {
Self {
meta: err.clone(),
kind: CancelJobErrorKind::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_access_denied_exception(&self) -> bool {
matches!(&self.kind, CancelJobErrorKind::AccessDeniedException(_))
}
pub fn is_incompatible_version_exception(&self) -> bool {
matches!(
&self.kind,
CancelJobErrorKind::IncompatibleVersionException(_)
)
}
pub fn is_internal_service_exception(&self) -> bool {
matches!(&self.kind, CancelJobErrorKind::InternalServiceException(_))
}
pub fn is_resource_in_use_exception(&self) -> bool {
matches!(&self.kind, CancelJobErrorKind::ResourceInUseException(_))
}
pub fn is_resource_not_found_exception(&self) -> bool {
matches!(&self.kind, CancelJobErrorKind::ResourceNotFoundException(_))
}
pub fn is_validation_exception(&self) -> bool {
matches!(&self.kind, CancelJobErrorKind::ValidationException(_))
}
}
impl std::error::Error for CancelJobError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.kind {
CancelJobErrorKind::AccessDeniedException(_inner) => Some(_inner),
CancelJobErrorKind::IncompatibleVersionException(_inner) => Some(_inner),
CancelJobErrorKind::InternalServiceException(_inner) => Some(_inner),
CancelJobErrorKind::ResourceInUseException(_inner) => Some(_inner),
CancelJobErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
CancelJobErrorKind::ValidationException(_inner) => Some(_inner),
CancelJobErrorKind::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 _)
}
}