#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum Error {
AlreadyExistsException(crate::types::error::AlreadyExistsException),
AssociatedInstances(crate::types::error::AssociatedInstances),
AssociationAlreadyExists(crate::types::error::AssociationAlreadyExists),
AssociationDoesNotExist(crate::types::error::AssociationDoesNotExist),
AssociationExecutionDoesNotExist(crate::types::error::AssociationExecutionDoesNotExist),
AssociationLimitExceeded(crate::types::error::AssociationLimitExceeded),
AssociationVersionLimitExceeded(crate::types::error::AssociationVersionLimitExceeded),
AutomationDefinitionNotApprovedException(
crate::types::error::AutomationDefinitionNotApprovedException,
),
AutomationDefinitionNotFoundException(
crate::types::error::AutomationDefinitionNotFoundException,
),
AutomationDefinitionVersionNotFoundException(
crate::types::error::AutomationDefinitionVersionNotFoundException,
),
AutomationExecutionLimitExceededException(
crate::types::error::AutomationExecutionLimitExceededException,
),
AutomationExecutionNotFoundException(crate::types::error::AutomationExecutionNotFoundException),
AutomationStepNotFoundException(crate::types::error::AutomationStepNotFoundException),
ComplianceTypeCountLimitExceededException(
crate::types::error::ComplianceTypeCountLimitExceededException,
),
CustomSchemaCountLimitExceededException(
crate::types::error::CustomSchemaCountLimitExceededException,
),
DocumentAlreadyExists(crate::types::error::DocumentAlreadyExists),
DocumentLimitExceeded(crate::types::error::DocumentLimitExceeded),
DocumentPermissionLimit(crate::types::error::DocumentPermissionLimit),
DocumentVersionLimitExceeded(crate::types::error::DocumentVersionLimitExceeded),
DoesNotExistException(crate::types::error::DoesNotExistException),
DuplicateDocumentContent(crate::types::error::DuplicateDocumentContent),
DuplicateDocumentVersionName(crate::types::error::DuplicateDocumentVersionName),
DuplicateInstanceId(crate::types::error::DuplicateInstanceId),
FeatureNotAvailableException(crate::types::error::FeatureNotAvailableException),
HierarchyLevelLimitExceededException(crate::types::error::HierarchyLevelLimitExceededException),
HierarchyTypeMismatchException(crate::types::error::HierarchyTypeMismatchException),
IdempotentParameterMismatch(crate::types::error::IdempotentParameterMismatch),
IncompatiblePolicyException(crate::types::error::IncompatiblePolicyException),
InternalServerError(crate::types::error::InternalServerError),
InvalidActivation(crate::types::error::InvalidActivation),
InvalidActivationId(crate::types::error::InvalidActivationId),
InvalidAggregatorException(crate::types::error::InvalidAggregatorException),
InvalidAllowedPatternException(crate::types::error::InvalidAllowedPatternException),
InvalidAssociation(crate::types::error::InvalidAssociation),
InvalidAssociationVersion(crate::types::error::InvalidAssociationVersion),
InvalidAutomationExecutionParametersException(
crate::types::error::InvalidAutomationExecutionParametersException,
),
InvalidAutomationSignalException(crate::types::error::InvalidAutomationSignalException),
InvalidAutomationStatusUpdateException(
crate::types::error::InvalidAutomationStatusUpdateException,
),
InvalidCommandId(crate::types::error::InvalidCommandId),
InvalidDeleteInventoryParametersException(
crate::types::error::InvalidDeleteInventoryParametersException,
),
InvalidDeletionIdException(crate::types::error::InvalidDeletionIdException),
InvalidDocument(crate::types::error::InvalidDocument),
InvalidDocumentContent(crate::types::error::InvalidDocumentContent),
InvalidDocumentOperation(crate::types::error::InvalidDocumentOperation),
InvalidDocumentSchemaVersion(crate::types::error::InvalidDocumentSchemaVersion),
InvalidDocumentType(crate::types::error::InvalidDocumentType),
InvalidDocumentVersion(crate::types::error::InvalidDocumentVersion),
InvalidFilter(crate::types::error::InvalidFilter),
InvalidFilterKey(crate::types::error::InvalidFilterKey),
InvalidFilterOption(crate::types::error::InvalidFilterOption),
InvalidFilterValue(crate::types::error::InvalidFilterValue),
InvalidInstanceId(crate::types::error::InvalidInstanceId),
InvalidInstanceInformationFilterValue(
crate::types::error::InvalidInstanceInformationFilterValue,
),
InvalidInventoryGroupException(crate::types::error::InvalidInventoryGroupException),
InvalidInventoryItemContextException(crate::types::error::InvalidInventoryItemContextException),
InvalidInventoryRequestException(crate::types::error::InvalidInventoryRequestException),
InvalidItemContentException(crate::types::error::InvalidItemContentException),
InvalidKeyId(crate::types::error::InvalidKeyId),
InvalidNextToken(crate::types::error::InvalidNextToken),
InvalidNotificationConfig(crate::types::error::InvalidNotificationConfig),
InvalidOptionException(crate::types::error::InvalidOptionException),
InvalidOutputFolder(crate::types::error::InvalidOutputFolder),
InvalidOutputLocation(crate::types::error::InvalidOutputLocation),
InvalidParameters(crate::types::error::InvalidParameters),
InvalidPermissionType(crate::types::error::InvalidPermissionType),
InvalidPluginName(crate::types::error::InvalidPluginName),
InvalidPolicyAttributeException(crate::types::error::InvalidPolicyAttributeException),
InvalidPolicyTypeException(crate::types::error::InvalidPolicyTypeException),
InvalidResourceId(crate::types::error::InvalidResourceId),
InvalidResourceType(crate::types::error::InvalidResourceType),
InvalidResultAttributeException(crate::types::error::InvalidResultAttributeException),
InvalidRole(crate::types::error::InvalidRole),
InvalidSchedule(crate::types::error::InvalidSchedule),
InvalidTag(crate::types::error::InvalidTag),
InvalidTarget(crate::types::error::InvalidTarget),
InvalidTargetMaps(crate::types::error::InvalidTargetMaps),
InvalidTypeNameException(crate::types::error::InvalidTypeNameException),
InvalidUpdate(crate::types::error::InvalidUpdate),
InvocationDoesNotExist(crate::types::error::InvocationDoesNotExist),
ItemContentMismatchException(crate::types::error::ItemContentMismatchException),
ItemSizeLimitExceededException(crate::types::error::ItemSizeLimitExceededException),
MaxDocumentSizeExceeded(crate::types::error::MaxDocumentSizeExceeded),
OpsItemAccessDeniedException(crate::types::error::OpsItemAccessDeniedException),
OpsItemAlreadyExistsException(crate::types::error::OpsItemAlreadyExistsException),
OpsItemInvalidParameterException(crate::types::error::OpsItemInvalidParameterException),
OpsItemLimitExceededException(crate::types::error::OpsItemLimitExceededException),
OpsItemNotFoundException(crate::types::error::OpsItemNotFoundException),
OpsItemRelatedItemAlreadyExistsException(
crate::types::error::OpsItemRelatedItemAlreadyExistsException,
),
OpsItemRelatedItemAssociationNotFoundException(
crate::types::error::OpsItemRelatedItemAssociationNotFoundException,
),
OpsMetadataAlreadyExistsException(crate::types::error::OpsMetadataAlreadyExistsException),
OpsMetadataInvalidArgumentException(crate::types::error::OpsMetadataInvalidArgumentException),
OpsMetadataKeyLimitExceededException(crate::types::error::OpsMetadataKeyLimitExceededException),
OpsMetadataLimitExceededException(crate::types::error::OpsMetadataLimitExceededException),
OpsMetadataNotFoundException(crate::types::error::OpsMetadataNotFoundException),
OpsMetadataTooManyUpdatesException(crate::types::error::OpsMetadataTooManyUpdatesException),
ParameterAlreadyExists(crate::types::error::ParameterAlreadyExists),
ParameterLimitExceeded(crate::types::error::ParameterLimitExceeded),
ParameterMaxVersionLimitExceeded(crate::types::error::ParameterMaxVersionLimitExceeded),
ParameterNotFound(crate::types::error::ParameterNotFound),
ParameterPatternMismatchException(crate::types::error::ParameterPatternMismatchException),
ParameterVersionLabelLimitExceeded(crate::types::error::ParameterVersionLabelLimitExceeded),
ParameterVersionNotFound(crate::types::error::ParameterVersionNotFound),
PoliciesLimitExceededException(crate::types::error::PoliciesLimitExceededException),
ResourceDataSyncAlreadyExistsException(
crate::types::error::ResourceDataSyncAlreadyExistsException,
),
ResourceDataSyncConflictException(crate::types::error::ResourceDataSyncConflictException),
ResourceDataSyncCountExceededException(
crate::types::error::ResourceDataSyncCountExceededException,
),
ResourceDataSyncInvalidConfigurationException(
crate::types::error::ResourceDataSyncInvalidConfigurationException,
),
ResourceDataSyncNotFoundException(crate::types::error::ResourceDataSyncNotFoundException),
ResourceInUseException(crate::types::error::ResourceInUseException),
ResourceLimitExceededException(crate::types::error::ResourceLimitExceededException),
ResourcePolicyConflictException(crate::types::error::ResourcePolicyConflictException),
ResourcePolicyInvalidParameterException(
crate::types::error::ResourcePolicyInvalidParameterException,
),
ResourcePolicyLimitExceededException(crate::types::error::ResourcePolicyLimitExceededException),
ServiceSettingNotFound(crate::types::error::ServiceSettingNotFound),
StatusUnchanged(crate::types::error::StatusUnchanged),
SubTypeCountLimitExceededException(crate::types::error::SubTypeCountLimitExceededException),
TargetInUseException(crate::types::error::TargetInUseException),
TargetNotConnected(crate::types::error::TargetNotConnected),
TooManyTagsError(crate::types::error::TooManyTagsError),
TooManyUpdates(crate::types::error::TooManyUpdates),
TotalSizeLimitExceededException(crate::types::error::TotalSizeLimitExceededException),
UnsupportedCalendarException(crate::types::error::UnsupportedCalendarException),
UnsupportedFeatureRequiredException(crate::types::error::UnsupportedFeatureRequiredException),
UnsupportedInventoryItemContextException(
crate::types::error::UnsupportedInventoryItemContextException,
),
UnsupportedInventorySchemaVersionException(
crate::types::error::UnsupportedInventorySchemaVersionException,
),
UnsupportedOperatingSystem(crate::types::error::UnsupportedOperatingSystem),
UnsupportedParameterType(crate::types::error::UnsupportedParameterType),
UnsupportedPlatformType(crate::types::error::UnsupportedPlatformType),
Unhandled(aws_smithy_types::error::Unhandled),
}
impl std::fmt::Display for Error {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Error::AlreadyExistsException(inner) => inner.fmt(f),
Error::AssociatedInstances(inner) => inner.fmt(f),
Error::AssociationAlreadyExists(inner) => inner.fmt(f),
Error::AssociationDoesNotExist(inner) => inner.fmt(f),
Error::AssociationExecutionDoesNotExist(inner) => inner.fmt(f),
Error::AssociationLimitExceeded(inner) => inner.fmt(f),
Error::AssociationVersionLimitExceeded(inner) => inner.fmt(f),
Error::AutomationDefinitionNotApprovedException(inner) => inner.fmt(f),
Error::AutomationDefinitionNotFoundException(inner) => inner.fmt(f),
Error::AutomationDefinitionVersionNotFoundException(inner) => inner.fmt(f),
Error::AutomationExecutionLimitExceededException(inner) => inner.fmt(f),
Error::AutomationExecutionNotFoundException(inner) => inner.fmt(f),
Error::AutomationStepNotFoundException(inner) => inner.fmt(f),
Error::ComplianceTypeCountLimitExceededException(inner) => inner.fmt(f),
Error::CustomSchemaCountLimitExceededException(inner) => inner.fmt(f),
Error::DocumentAlreadyExists(inner) => inner.fmt(f),
Error::DocumentLimitExceeded(inner) => inner.fmt(f),
Error::DocumentPermissionLimit(inner) => inner.fmt(f),
Error::DocumentVersionLimitExceeded(inner) => inner.fmt(f),
Error::DoesNotExistException(inner) => inner.fmt(f),
Error::DuplicateDocumentContent(inner) => inner.fmt(f),
Error::DuplicateDocumentVersionName(inner) => inner.fmt(f),
Error::DuplicateInstanceId(inner) => inner.fmt(f),
Error::FeatureNotAvailableException(inner) => inner.fmt(f),
Error::HierarchyLevelLimitExceededException(inner) => inner.fmt(f),
Error::HierarchyTypeMismatchException(inner) => inner.fmt(f),
Error::IdempotentParameterMismatch(inner) => inner.fmt(f),
Error::IncompatiblePolicyException(inner) => inner.fmt(f),
Error::InternalServerError(inner) => inner.fmt(f),
Error::InvalidActivation(inner) => inner.fmt(f),
Error::InvalidActivationId(inner) => inner.fmt(f),
Error::InvalidAggregatorException(inner) => inner.fmt(f),
Error::InvalidAllowedPatternException(inner) => inner.fmt(f),
Error::InvalidAssociation(inner) => inner.fmt(f),
Error::InvalidAssociationVersion(inner) => inner.fmt(f),
Error::InvalidAutomationExecutionParametersException(inner) => inner.fmt(f),
Error::InvalidAutomationSignalException(inner) => inner.fmt(f),
Error::InvalidAutomationStatusUpdateException(inner) => inner.fmt(f),
Error::InvalidCommandId(inner) => inner.fmt(f),
Error::InvalidDeleteInventoryParametersException(inner) => inner.fmt(f),
Error::InvalidDeletionIdException(inner) => inner.fmt(f),
Error::InvalidDocument(inner) => inner.fmt(f),
Error::InvalidDocumentContent(inner) => inner.fmt(f),
Error::InvalidDocumentOperation(inner) => inner.fmt(f),
Error::InvalidDocumentSchemaVersion(inner) => inner.fmt(f),
Error::InvalidDocumentType(inner) => inner.fmt(f),
Error::InvalidDocumentVersion(inner) => inner.fmt(f),
Error::InvalidFilter(inner) => inner.fmt(f),
Error::InvalidFilterKey(inner) => inner.fmt(f),
Error::InvalidFilterOption(inner) => inner.fmt(f),
Error::InvalidFilterValue(inner) => inner.fmt(f),
Error::InvalidInstanceId(inner) => inner.fmt(f),
Error::InvalidInstanceInformationFilterValue(inner) => inner.fmt(f),
Error::InvalidInventoryGroupException(inner) => inner.fmt(f),
Error::InvalidInventoryItemContextException(inner) => inner.fmt(f),
Error::InvalidInventoryRequestException(inner) => inner.fmt(f),
Error::InvalidItemContentException(inner) => inner.fmt(f),
Error::InvalidKeyId(inner) => inner.fmt(f),
Error::InvalidNextToken(inner) => inner.fmt(f),
Error::InvalidNotificationConfig(inner) => inner.fmt(f),
Error::InvalidOptionException(inner) => inner.fmt(f),
Error::InvalidOutputFolder(inner) => inner.fmt(f),
Error::InvalidOutputLocation(inner) => inner.fmt(f),
Error::InvalidParameters(inner) => inner.fmt(f),
Error::InvalidPermissionType(inner) => inner.fmt(f),
Error::InvalidPluginName(inner) => inner.fmt(f),
Error::InvalidPolicyAttributeException(inner) => inner.fmt(f),
Error::InvalidPolicyTypeException(inner) => inner.fmt(f),
Error::InvalidResourceId(inner) => inner.fmt(f),
Error::InvalidResourceType(inner) => inner.fmt(f),
Error::InvalidResultAttributeException(inner) => inner.fmt(f),
Error::InvalidRole(inner) => inner.fmt(f),
Error::InvalidSchedule(inner) => inner.fmt(f),
Error::InvalidTag(inner) => inner.fmt(f),
Error::InvalidTarget(inner) => inner.fmt(f),
Error::InvalidTargetMaps(inner) => inner.fmt(f),
Error::InvalidTypeNameException(inner) => inner.fmt(f),
Error::InvalidUpdate(inner) => inner.fmt(f),
Error::InvocationDoesNotExist(inner) => inner.fmt(f),
Error::ItemContentMismatchException(inner) => inner.fmt(f),
Error::ItemSizeLimitExceededException(inner) => inner.fmt(f),
Error::MaxDocumentSizeExceeded(inner) => inner.fmt(f),
Error::OpsItemAccessDeniedException(inner) => inner.fmt(f),
Error::OpsItemAlreadyExistsException(inner) => inner.fmt(f),
Error::OpsItemInvalidParameterException(inner) => inner.fmt(f),
Error::OpsItemLimitExceededException(inner) => inner.fmt(f),
Error::OpsItemNotFoundException(inner) => inner.fmt(f),
Error::OpsItemRelatedItemAlreadyExistsException(inner) => inner.fmt(f),
Error::OpsItemRelatedItemAssociationNotFoundException(inner) => inner.fmt(f),
Error::OpsMetadataAlreadyExistsException(inner) => inner.fmt(f),
Error::OpsMetadataInvalidArgumentException(inner) => inner.fmt(f),
Error::OpsMetadataKeyLimitExceededException(inner) => inner.fmt(f),
Error::OpsMetadataLimitExceededException(inner) => inner.fmt(f),
Error::OpsMetadataNotFoundException(inner) => inner.fmt(f),
Error::OpsMetadataTooManyUpdatesException(inner) => inner.fmt(f),
Error::ParameterAlreadyExists(inner) => inner.fmt(f),
Error::ParameterLimitExceeded(inner) => inner.fmt(f),
Error::ParameterMaxVersionLimitExceeded(inner) => inner.fmt(f),
Error::ParameterNotFound(inner) => inner.fmt(f),
Error::ParameterPatternMismatchException(inner) => inner.fmt(f),
Error::ParameterVersionLabelLimitExceeded(inner) => inner.fmt(f),
Error::ParameterVersionNotFound(inner) => inner.fmt(f),
Error::PoliciesLimitExceededException(inner) => inner.fmt(f),
Error::ResourceDataSyncAlreadyExistsException(inner) => inner.fmt(f),
Error::ResourceDataSyncConflictException(inner) => inner.fmt(f),
Error::ResourceDataSyncCountExceededException(inner) => inner.fmt(f),
Error::ResourceDataSyncInvalidConfigurationException(inner) => inner.fmt(f),
Error::ResourceDataSyncNotFoundException(inner) => inner.fmt(f),
Error::ResourceInUseException(inner) => inner.fmt(f),
Error::ResourceLimitExceededException(inner) => inner.fmt(f),
Error::ResourcePolicyConflictException(inner) => inner.fmt(f),
Error::ResourcePolicyInvalidParameterException(inner) => inner.fmt(f),
Error::ResourcePolicyLimitExceededException(inner) => inner.fmt(f),
Error::ServiceSettingNotFound(inner) => inner.fmt(f),
Error::StatusUnchanged(inner) => inner.fmt(f),
Error::SubTypeCountLimitExceededException(inner) => inner.fmt(f),
Error::TargetInUseException(inner) => inner.fmt(f),
Error::TargetNotConnected(inner) => inner.fmt(f),
Error::TooManyTagsError(inner) => inner.fmt(f),
Error::TooManyUpdates(inner) => inner.fmt(f),
Error::TotalSizeLimitExceededException(inner) => inner.fmt(f),
Error::UnsupportedCalendarException(inner) => inner.fmt(f),
Error::UnsupportedFeatureRequiredException(inner) => inner.fmt(f),
Error::UnsupportedInventoryItemContextException(inner) => inner.fmt(f),
Error::UnsupportedInventorySchemaVersionException(inner) => inner.fmt(f),
Error::UnsupportedOperatingSystem(inner) => inner.fmt(f),
Error::UnsupportedParameterType(inner) => inner.fmt(f),
Error::UnsupportedPlatformType(inner) => inner.fmt(f),
Error::Unhandled(inner) => inner.fmt(f),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::add_tags_to_resource::AddTagsToResourceError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::add_tags_to_resource::AddTagsToResourceError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::add_tags_to_resource::AddTagsToResourceError> for Error {
fn from(err: crate::operation::add_tags_to_resource::AddTagsToResourceError) -> Self {
match err {
crate::operation::add_tags_to_resource::AddTagsToResourceError::InternalServerError(
inner,
) => Error::InternalServerError(inner),
crate::operation::add_tags_to_resource::AddTagsToResourceError::InvalidResourceId(
inner,
) => Error::InvalidResourceId(inner),
crate::operation::add_tags_to_resource::AddTagsToResourceError::InvalidResourceType(
inner,
) => Error::InvalidResourceType(inner),
crate::operation::add_tags_to_resource::AddTagsToResourceError::TooManyTagsError(
inner,
) => Error::TooManyTagsError(inner),
crate::operation::add_tags_to_resource::AddTagsToResourceError::TooManyUpdates(
inner,
) => Error::TooManyUpdates(inner),
crate::operation::add_tags_to_resource::AddTagsToResourceError::Unhandled(inner) => {
Error::Unhandled(inner)
}
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::associate_ops_item_related_item::AssociateOpsItemRelatedItemError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::associate_ops_item_related_item::AssociateOpsItemRelatedItemError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::associate_ops_item_related_item::AssociateOpsItemRelatedItemError>
for Error
{
fn from(
err: crate::operation::associate_ops_item_related_item::AssociateOpsItemRelatedItemError,
) -> Self {
match err {
crate::operation::associate_ops_item_related_item::AssociateOpsItemRelatedItemError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::associate_ops_item_related_item::AssociateOpsItemRelatedItemError::OpsItemInvalidParameterException(inner) => Error::OpsItemInvalidParameterException(inner),
crate::operation::associate_ops_item_related_item::AssociateOpsItemRelatedItemError::OpsItemLimitExceededException(inner) => Error::OpsItemLimitExceededException(inner),
crate::operation::associate_ops_item_related_item::AssociateOpsItemRelatedItemError::OpsItemNotFoundException(inner) => Error::OpsItemNotFoundException(inner),
crate::operation::associate_ops_item_related_item::AssociateOpsItemRelatedItemError::OpsItemRelatedItemAlreadyExistsException(inner) => Error::OpsItemRelatedItemAlreadyExistsException(inner),
crate::operation::associate_ops_item_related_item::AssociateOpsItemRelatedItemError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<aws_smithy_http::result::SdkError<crate::operation::cancel_command::CancelCommandError, R>>
for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::cancel_command::CancelCommandError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::cancel_command::CancelCommandError> for Error {
fn from(err: crate::operation::cancel_command::CancelCommandError) -> Self {
match err {
crate::operation::cancel_command::CancelCommandError::DuplicateInstanceId(inner) => {
Error::DuplicateInstanceId(inner)
}
crate::operation::cancel_command::CancelCommandError::InternalServerError(inner) => {
Error::InternalServerError(inner)
}
crate::operation::cancel_command::CancelCommandError::InvalidCommandId(inner) => {
Error::InvalidCommandId(inner)
}
crate::operation::cancel_command::CancelCommandError::InvalidInstanceId(inner) => {
Error::InvalidInstanceId(inner)
}
crate::operation::cancel_command::CancelCommandError::Unhandled(inner) => {
Error::Unhandled(inner)
}
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::cancel_maintenance_window_execution::CancelMaintenanceWindowExecutionError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
fn from(err: aws_smithy_http::result::SdkError<crate::operation::cancel_maintenance_window_execution::CancelMaintenanceWindowExecutionError, R>) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
.source(err)
.build()
),
}
}
}
impl From<crate::operation::cancel_maintenance_window_execution::CancelMaintenanceWindowExecutionError> for Error {
fn from(err: crate::operation::cancel_maintenance_window_execution::CancelMaintenanceWindowExecutionError) -> Self {
match err {
crate::operation::cancel_maintenance_window_execution::CancelMaintenanceWindowExecutionError::DoesNotExistException(inner) => Error::DoesNotExistException(inner),
crate::operation::cancel_maintenance_window_execution::CancelMaintenanceWindowExecutionError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::cancel_maintenance_window_execution::CancelMaintenanceWindowExecutionError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::create_activation::CreateActivationError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::create_activation::CreateActivationError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::create_activation::CreateActivationError> for Error {
fn from(err: crate::operation::create_activation::CreateActivationError) -> Self {
match err {
crate::operation::create_activation::CreateActivationError::InternalServerError(
inner,
) => Error::InternalServerError(inner),
crate::operation::create_activation::CreateActivationError::InvalidParameters(
inner,
) => Error::InvalidParameters(inner),
crate::operation::create_activation::CreateActivationError::Unhandled(inner) => {
Error::Unhandled(inner)
}
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::create_association::CreateAssociationError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::create_association::CreateAssociationError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::create_association::CreateAssociationError> for Error {
fn from(err: crate::operation::create_association::CreateAssociationError) -> Self {
match err {
crate::operation::create_association::CreateAssociationError::AssociationAlreadyExists(inner) => Error::AssociationAlreadyExists(inner),
crate::operation::create_association::CreateAssociationError::AssociationLimitExceeded(inner) => Error::AssociationLimitExceeded(inner),
crate::operation::create_association::CreateAssociationError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::create_association::CreateAssociationError::InvalidDocument(inner) => Error::InvalidDocument(inner),
crate::operation::create_association::CreateAssociationError::InvalidDocumentVersion(inner) => Error::InvalidDocumentVersion(inner),
crate::operation::create_association::CreateAssociationError::InvalidInstanceId(inner) => Error::InvalidInstanceId(inner),
crate::operation::create_association::CreateAssociationError::InvalidOutputLocation(inner) => Error::InvalidOutputLocation(inner),
crate::operation::create_association::CreateAssociationError::InvalidParameters(inner) => Error::InvalidParameters(inner),
crate::operation::create_association::CreateAssociationError::InvalidSchedule(inner) => Error::InvalidSchedule(inner),
crate::operation::create_association::CreateAssociationError::InvalidTag(inner) => Error::InvalidTag(inner),
crate::operation::create_association::CreateAssociationError::InvalidTarget(inner) => Error::InvalidTarget(inner),
crate::operation::create_association::CreateAssociationError::InvalidTargetMaps(inner) => Error::InvalidTargetMaps(inner),
crate::operation::create_association::CreateAssociationError::UnsupportedPlatformType(inner) => Error::UnsupportedPlatformType(inner),
crate::operation::create_association::CreateAssociationError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::create_association_batch::CreateAssociationBatchError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::create_association_batch::CreateAssociationBatchError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::create_association_batch::CreateAssociationBatchError> for Error {
fn from(err: crate::operation::create_association_batch::CreateAssociationBatchError) -> Self {
match err {
crate::operation::create_association_batch::CreateAssociationBatchError::AssociationLimitExceeded(inner) => Error::AssociationLimitExceeded(inner),
crate::operation::create_association_batch::CreateAssociationBatchError::DuplicateInstanceId(inner) => Error::DuplicateInstanceId(inner),
crate::operation::create_association_batch::CreateAssociationBatchError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::create_association_batch::CreateAssociationBatchError::InvalidDocument(inner) => Error::InvalidDocument(inner),
crate::operation::create_association_batch::CreateAssociationBatchError::InvalidDocumentVersion(inner) => Error::InvalidDocumentVersion(inner),
crate::operation::create_association_batch::CreateAssociationBatchError::InvalidInstanceId(inner) => Error::InvalidInstanceId(inner),
crate::operation::create_association_batch::CreateAssociationBatchError::InvalidOutputLocation(inner) => Error::InvalidOutputLocation(inner),
crate::operation::create_association_batch::CreateAssociationBatchError::InvalidParameters(inner) => Error::InvalidParameters(inner),
crate::operation::create_association_batch::CreateAssociationBatchError::InvalidSchedule(inner) => Error::InvalidSchedule(inner),
crate::operation::create_association_batch::CreateAssociationBatchError::InvalidTarget(inner) => Error::InvalidTarget(inner),
crate::operation::create_association_batch::CreateAssociationBatchError::InvalidTargetMaps(inner) => Error::InvalidTargetMaps(inner),
crate::operation::create_association_batch::CreateAssociationBatchError::UnsupportedPlatformType(inner) => Error::UnsupportedPlatformType(inner),
crate::operation::create_association_batch::CreateAssociationBatchError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::create_document::CreateDocumentError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::create_document::CreateDocumentError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::create_document::CreateDocumentError> for Error {
fn from(err: crate::operation::create_document::CreateDocumentError) -> Self {
match err {
crate::operation::create_document::CreateDocumentError::DocumentAlreadyExists(inner) => Error::DocumentAlreadyExists(inner),
crate::operation::create_document::CreateDocumentError::DocumentLimitExceeded(inner) => Error::DocumentLimitExceeded(inner),
crate::operation::create_document::CreateDocumentError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::create_document::CreateDocumentError::InvalidDocumentContent(inner) => Error::InvalidDocumentContent(inner),
crate::operation::create_document::CreateDocumentError::InvalidDocumentSchemaVersion(inner) => Error::InvalidDocumentSchemaVersion(inner),
crate::operation::create_document::CreateDocumentError::MaxDocumentSizeExceeded(inner) => Error::MaxDocumentSizeExceeded(inner),
crate::operation::create_document::CreateDocumentError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::create_maintenance_window::CreateMaintenanceWindowError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::create_maintenance_window::CreateMaintenanceWindowError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::create_maintenance_window::CreateMaintenanceWindowError> for Error {
fn from(
err: crate::operation::create_maintenance_window::CreateMaintenanceWindowError,
) -> Self {
match err {
crate::operation::create_maintenance_window::CreateMaintenanceWindowError::IdempotentParameterMismatch(inner) => Error::IdempotentParameterMismatch(inner),
crate::operation::create_maintenance_window::CreateMaintenanceWindowError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::create_maintenance_window::CreateMaintenanceWindowError::ResourceLimitExceededException(inner) => Error::ResourceLimitExceededException(inner),
crate::operation::create_maintenance_window::CreateMaintenanceWindowError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<crate::operation::create_ops_item::CreateOpsItemError, R>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::create_ops_item::CreateOpsItemError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::create_ops_item::CreateOpsItemError> for Error {
fn from(err: crate::operation::create_ops_item::CreateOpsItemError) -> Self {
match err {
crate::operation::create_ops_item::CreateOpsItemError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::create_ops_item::CreateOpsItemError::OpsItemAccessDeniedException(inner) => Error::OpsItemAccessDeniedException(inner),
crate::operation::create_ops_item::CreateOpsItemError::OpsItemAlreadyExistsException(inner) => Error::OpsItemAlreadyExistsException(inner),
crate::operation::create_ops_item::CreateOpsItemError::OpsItemInvalidParameterException(inner) => Error::OpsItemInvalidParameterException(inner),
crate::operation::create_ops_item::CreateOpsItemError::OpsItemLimitExceededException(inner) => Error::OpsItemLimitExceededException(inner),
crate::operation::create_ops_item::CreateOpsItemError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::create_ops_metadata::CreateOpsMetadataError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::create_ops_metadata::CreateOpsMetadataError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::create_ops_metadata::CreateOpsMetadataError> for Error {
fn from(err: crate::operation::create_ops_metadata::CreateOpsMetadataError) -> Self {
match err {
crate::operation::create_ops_metadata::CreateOpsMetadataError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::create_ops_metadata::CreateOpsMetadataError::OpsMetadataAlreadyExistsException(inner) => Error::OpsMetadataAlreadyExistsException(inner),
crate::operation::create_ops_metadata::CreateOpsMetadataError::OpsMetadataInvalidArgumentException(inner) => Error::OpsMetadataInvalidArgumentException(inner),
crate::operation::create_ops_metadata::CreateOpsMetadataError::OpsMetadataLimitExceededException(inner) => Error::OpsMetadataLimitExceededException(inner),
crate::operation::create_ops_metadata::CreateOpsMetadataError::OpsMetadataTooManyUpdatesException(inner) => Error::OpsMetadataTooManyUpdatesException(inner),
crate::operation::create_ops_metadata::CreateOpsMetadataError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::create_patch_baseline::CreatePatchBaselineError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::create_patch_baseline::CreatePatchBaselineError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::create_patch_baseline::CreatePatchBaselineError> for Error {
fn from(err: crate::operation::create_patch_baseline::CreatePatchBaselineError) -> Self {
match err {
crate::operation::create_patch_baseline::CreatePatchBaselineError::IdempotentParameterMismatch(inner) => Error::IdempotentParameterMismatch(inner),
crate::operation::create_patch_baseline::CreatePatchBaselineError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::create_patch_baseline::CreatePatchBaselineError::ResourceLimitExceededException(inner) => Error::ResourceLimitExceededException(inner),
crate::operation::create_patch_baseline::CreatePatchBaselineError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::create_resource_data_sync::CreateResourceDataSyncError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::create_resource_data_sync::CreateResourceDataSyncError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::create_resource_data_sync::CreateResourceDataSyncError> for Error {
fn from(err: crate::operation::create_resource_data_sync::CreateResourceDataSyncError) -> Self {
match err {
crate::operation::create_resource_data_sync::CreateResourceDataSyncError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::create_resource_data_sync::CreateResourceDataSyncError::ResourceDataSyncAlreadyExistsException(inner) => Error::ResourceDataSyncAlreadyExistsException(inner),
crate::operation::create_resource_data_sync::CreateResourceDataSyncError::ResourceDataSyncCountExceededException(inner) => Error::ResourceDataSyncCountExceededException(inner),
crate::operation::create_resource_data_sync::CreateResourceDataSyncError::ResourceDataSyncInvalidConfigurationException(inner) => Error::ResourceDataSyncInvalidConfigurationException(inner),
crate::operation::create_resource_data_sync::CreateResourceDataSyncError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::delete_activation::DeleteActivationError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::delete_activation::DeleteActivationError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::delete_activation::DeleteActivationError> for Error {
fn from(err: crate::operation::delete_activation::DeleteActivationError) -> Self {
match err {
crate::operation::delete_activation::DeleteActivationError::InternalServerError(
inner,
) => Error::InternalServerError(inner),
crate::operation::delete_activation::DeleteActivationError::InvalidActivation(
inner,
) => Error::InvalidActivation(inner),
crate::operation::delete_activation::DeleteActivationError::InvalidActivationId(
inner,
) => Error::InvalidActivationId(inner),
crate::operation::delete_activation::DeleteActivationError::TooManyUpdates(inner) => {
Error::TooManyUpdates(inner)
}
crate::operation::delete_activation::DeleteActivationError::Unhandled(inner) => {
Error::Unhandled(inner)
}
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::delete_association::DeleteAssociationError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::delete_association::DeleteAssociationError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::delete_association::DeleteAssociationError> for Error {
fn from(err: crate::operation::delete_association::DeleteAssociationError) -> Self {
match err {
crate::operation::delete_association::DeleteAssociationError::AssociationDoesNotExist(inner) => Error::AssociationDoesNotExist(inner),
crate::operation::delete_association::DeleteAssociationError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::delete_association::DeleteAssociationError::InvalidDocument(inner) => Error::InvalidDocument(inner),
crate::operation::delete_association::DeleteAssociationError::InvalidInstanceId(inner) => Error::InvalidInstanceId(inner),
crate::operation::delete_association::DeleteAssociationError::TooManyUpdates(inner) => Error::TooManyUpdates(inner),
crate::operation::delete_association::DeleteAssociationError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::delete_document::DeleteDocumentError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::delete_document::DeleteDocumentError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::delete_document::DeleteDocumentError> for Error {
fn from(err: crate::operation::delete_document::DeleteDocumentError) -> Self {
match err {
crate::operation::delete_document::DeleteDocumentError::AssociatedInstances(inner) => {
Error::AssociatedInstances(inner)
}
crate::operation::delete_document::DeleteDocumentError::InternalServerError(inner) => {
Error::InternalServerError(inner)
}
crate::operation::delete_document::DeleteDocumentError::InvalidDocument(inner) => {
Error::InvalidDocument(inner)
}
crate::operation::delete_document::DeleteDocumentError::InvalidDocumentOperation(
inner,
) => Error::InvalidDocumentOperation(inner),
crate::operation::delete_document::DeleteDocumentError::Unhandled(inner) => {
Error::Unhandled(inner)
}
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::delete_inventory::DeleteInventoryError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::delete_inventory::DeleteInventoryError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::delete_inventory::DeleteInventoryError> for Error {
fn from(err: crate::operation::delete_inventory::DeleteInventoryError) -> Self {
match err {
crate::operation::delete_inventory::DeleteInventoryError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::delete_inventory::DeleteInventoryError::InvalidDeleteInventoryParametersException(inner) => Error::InvalidDeleteInventoryParametersException(inner),
crate::operation::delete_inventory::DeleteInventoryError::InvalidInventoryRequestException(inner) => Error::InvalidInventoryRequestException(inner),
crate::operation::delete_inventory::DeleteInventoryError::InvalidOptionException(inner) => Error::InvalidOptionException(inner),
crate::operation::delete_inventory::DeleteInventoryError::InvalidTypeNameException(inner) => Error::InvalidTypeNameException(inner),
crate::operation::delete_inventory::DeleteInventoryError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::delete_maintenance_window::DeleteMaintenanceWindowError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::delete_maintenance_window::DeleteMaintenanceWindowError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::delete_maintenance_window::DeleteMaintenanceWindowError> for Error {
fn from(
err: crate::operation::delete_maintenance_window::DeleteMaintenanceWindowError,
) -> Self {
match err {
crate::operation::delete_maintenance_window::DeleteMaintenanceWindowError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::delete_maintenance_window::DeleteMaintenanceWindowError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::delete_ops_metadata::DeleteOpsMetadataError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::delete_ops_metadata::DeleteOpsMetadataError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::delete_ops_metadata::DeleteOpsMetadataError> for Error {
fn from(err: crate::operation::delete_ops_metadata::DeleteOpsMetadataError) -> Self {
match err {
crate::operation::delete_ops_metadata::DeleteOpsMetadataError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::delete_ops_metadata::DeleteOpsMetadataError::OpsMetadataInvalidArgumentException(inner) => Error::OpsMetadataInvalidArgumentException(inner),
crate::operation::delete_ops_metadata::DeleteOpsMetadataError::OpsMetadataNotFoundException(inner) => Error::OpsMetadataNotFoundException(inner),
crate::operation::delete_ops_metadata::DeleteOpsMetadataError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::delete_parameter::DeleteParameterError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::delete_parameter::DeleteParameterError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::delete_parameter::DeleteParameterError> for Error {
fn from(err: crate::operation::delete_parameter::DeleteParameterError) -> Self {
match err {
crate::operation::delete_parameter::DeleteParameterError::InternalServerError(
inner,
) => Error::InternalServerError(inner),
crate::operation::delete_parameter::DeleteParameterError::ParameterNotFound(inner) => {
Error::ParameterNotFound(inner)
}
crate::operation::delete_parameter::DeleteParameterError::Unhandled(inner) => {
Error::Unhandled(inner)
}
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::delete_parameters::DeleteParametersError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::delete_parameters::DeleteParametersError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::delete_parameters::DeleteParametersError> for Error {
fn from(err: crate::operation::delete_parameters::DeleteParametersError) -> Self {
match err {
crate::operation::delete_parameters::DeleteParametersError::InternalServerError(
inner,
) => Error::InternalServerError(inner),
crate::operation::delete_parameters::DeleteParametersError::Unhandled(inner) => {
Error::Unhandled(inner)
}
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::delete_patch_baseline::DeletePatchBaselineError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::delete_patch_baseline::DeletePatchBaselineError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::delete_patch_baseline::DeletePatchBaselineError> for Error {
fn from(err: crate::operation::delete_patch_baseline::DeletePatchBaselineError) -> Self {
match err {
crate::operation::delete_patch_baseline::DeletePatchBaselineError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::delete_patch_baseline::DeletePatchBaselineError::ResourceInUseException(inner) => Error::ResourceInUseException(inner),
crate::operation::delete_patch_baseline::DeletePatchBaselineError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::delete_resource_data_sync::DeleteResourceDataSyncError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::delete_resource_data_sync::DeleteResourceDataSyncError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::delete_resource_data_sync::DeleteResourceDataSyncError> for Error {
fn from(err: crate::operation::delete_resource_data_sync::DeleteResourceDataSyncError) -> Self {
match err {
crate::operation::delete_resource_data_sync::DeleteResourceDataSyncError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::delete_resource_data_sync::DeleteResourceDataSyncError::ResourceDataSyncInvalidConfigurationException(inner) => Error::ResourceDataSyncInvalidConfigurationException(inner),
crate::operation::delete_resource_data_sync::DeleteResourceDataSyncError::ResourceDataSyncNotFoundException(inner) => Error::ResourceDataSyncNotFoundException(inner),
crate::operation::delete_resource_data_sync::DeleteResourceDataSyncError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::delete_resource_policy::DeleteResourcePolicyError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::delete_resource_policy::DeleteResourcePolicyError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::delete_resource_policy::DeleteResourcePolicyError> for Error {
fn from(err: crate::operation::delete_resource_policy::DeleteResourcePolicyError) -> Self {
match err {
crate::operation::delete_resource_policy::DeleteResourcePolicyError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::delete_resource_policy::DeleteResourcePolicyError::ResourcePolicyConflictException(inner) => Error::ResourcePolicyConflictException(inner),
crate::operation::delete_resource_policy::DeleteResourcePolicyError::ResourcePolicyInvalidParameterException(inner) => Error::ResourcePolicyInvalidParameterException(inner),
crate::operation::delete_resource_policy::DeleteResourcePolicyError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::deregister_managed_instance::DeregisterManagedInstanceError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::deregister_managed_instance::DeregisterManagedInstanceError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::deregister_managed_instance::DeregisterManagedInstanceError> for Error {
fn from(
err: crate::operation::deregister_managed_instance::DeregisterManagedInstanceError,
) -> Self {
match err {
crate::operation::deregister_managed_instance::DeregisterManagedInstanceError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::deregister_managed_instance::DeregisterManagedInstanceError::InvalidInstanceId(inner) => Error::InvalidInstanceId(inner),
crate::operation::deregister_managed_instance::DeregisterManagedInstanceError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::deregister_patch_baseline_for_patch_group::DeregisterPatchBaselineForPatchGroupError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
fn from(err: aws_smithy_http::result::SdkError<crate::operation::deregister_patch_baseline_for_patch_group::DeregisterPatchBaselineForPatchGroupError, R>) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
.source(err)
.build()
),
}
}
}
impl From<crate::operation::deregister_patch_baseline_for_patch_group::DeregisterPatchBaselineForPatchGroupError> for Error {
fn from(err: crate::operation::deregister_patch_baseline_for_patch_group::DeregisterPatchBaselineForPatchGroupError) -> Self {
match err {
crate::operation::deregister_patch_baseline_for_patch_group::DeregisterPatchBaselineForPatchGroupError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::deregister_patch_baseline_for_patch_group::DeregisterPatchBaselineForPatchGroupError::InvalidResourceId(inner) => Error::InvalidResourceId(inner),
crate::operation::deregister_patch_baseline_for_patch_group::DeregisterPatchBaselineForPatchGroupError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::deregister_target_from_maintenance_window::DeregisterTargetFromMaintenanceWindowError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
fn from(err: aws_smithy_http::result::SdkError<crate::operation::deregister_target_from_maintenance_window::DeregisterTargetFromMaintenanceWindowError, R>) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
.source(err)
.build()
),
}
}
}
impl From<crate::operation::deregister_target_from_maintenance_window::DeregisterTargetFromMaintenanceWindowError> for Error {
fn from(err: crate::operation::deregister_target_from_maintenance_window::DeregisterTargetFromMaintenanceWindowError) -> Self {
match err {
crate::operation::deregister_target_from_maintenance_window::DeregisterTargetFromMaintenanceWindowError::DoesNotExistException(inner) => Error::DoesNotExistException(inner),
crate::operation::deregister_target_from_maintenance_window::DeregisterTargetFromMaintenanceWindowError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::deregister_target_from_maintenance_window::DeregisterTargetFromMaintenanceWindowError::TargetInUseException(inner) => Error::TargetInUseException(inner),
crate::operation::deregister_target_from_maintenance_window::DeregisterTargetFromMaintenanceWindowError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::deregister_task_from_maintenance_window::DeregisterTaskFromMaintenanceWindowError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
fn from(err: aws_smithy_http::result::SdkError<crate::operation::deregister_task_from_maintenance_window::DeregisterTaskFromMaintenanceWindowError, R>) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
.source(err)
.build()
),
}
}
}
impl From<crate::operation::deregister_task_from_maintenance_window::DeregisterTaskFromMaintenanceWindowError> for Error {
fn from(err: crate::operation::deregister_task_from_maintenance_window::DeregisterTaskFromMaintenanceWindowError) -> Self {
match err {
crate::operation::deregister_task_from_maintenance_window::DeregisterTaskFromMaintenanceWindowError::DoesNotExistException(inner) => Error::DoesNotExistException(inner),
crate::operation::deregister_task_from_maintenance_window::DeregisterTaskFromMaintenanceWindowError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::deregister_task_from_maintenance_window::DeregisterTaskFromMaintenanceWindowError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::describe_activations::DescribeActivationsError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::describe_activations::DescribeActivationsError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::describe_activations::DescribeActivationsError> for Error {
fn from(err: crate::operation::describe_activations::DescribeActivationsError) -> Self {
match err {
crate::operation::describe_activations::DescribeActivationsError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_activations::DescribeActivationsError::InvalidFilter(inner) => Error::InvalidFilter(inner),
crate::operation::describe_activations::DescribeActivationsError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::describe_activations::DescribeActivationsError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::describe_association::DescribeAssociationError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::describe_association::DescribeAssociationError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::describe_association::DescribeAssociationError> for Error {
fn from(err: crate::operation::describe_association::DescribeAssociationError) -> Self {
match err {
crate::operation::describe_association::DescribeAssociationError::AssociationDoesNotExist(inner) => Error::AssociationDoesNotExist(inner),
crate::operation::describe_association::DescribeAssociationError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_association::DescribeAssociationError::InvalidAssociationVersion(inner) => Error::InvalidAssociationVersion(inner),
crate::operation::describe_association::DescribeAssociationError::InvalidDocument(inner) => Error::InvalidDocument(inner),
crate::operation::describe_association::DescribeAssociationError::InvalidInstanceId(inner) => Error::InvalidInstanceId(inner),
crate::operation::describe_association::DescribeAssociationError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::describe_association_executions::DescribeAssociationExecutionsError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::describe_association_executions::DescribeAssociationExecutionsError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::describe_association_executions::DescribeAssociationExecutionsError>
for Error
{
fn from(
err: crate::operation::describe_association_executions::DescribeAssociationExecutionsError,
) -> Self {
match err {
crate::operation::describe_association_executions::DescribeAssociationExecutionsError::AssociationDoesNotExist(inner) => Error::AssociationDoesNotExist(inner),
crate::operation::describe_association_executions::DescribeAssociationExecutionsError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_association_executions::DescribeAssociationExecutionsError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::describe_association_executions::DescribeAssociationExecutionsError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::describe_association_execution_targets::DescribeAssociationExecutionTargetsError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
fn from(err: aws_smithy_http::result::SdkError<crate::operation::describe_association_execution_targets::DescribeAssociationExecutionTargetsError, R>) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
.source(err)
.build()
),
}
}
}
impl From<crate::operation::describe_association_execution_targets::DescribeAssociationExecutionTargetsError> for Error {
fn from(err: crate::operation::describe_association_execution_targets::DescribeAssociationExecutionTargetsError) -> Self {
match err {
crate::operation::describe_association_execution_targets::DescribeAssociationExecutionTargetsError::AssociationDoesNotExist(inner) => Error::AssociationDoesNotExist(inner),
crate::operation::describe_association_execution_targets::DescribeAssociationExecutionTargetsError::AssociationExecutionDoesNotExist(inner) => Error::AssociationExecutionDoesNotExist(inner),
crate::operation::describe_association_execution_targets::DescribeAssociationExecutionTargetsError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_association_execution_targets::DescribeAssociationExecutionTargetsError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::describe_association_execution_targets::DescribeAssociationExecutionTargetsError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::describe_automation_executions::DescribeAutomationExecutionsError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::describe_automation_executions::DescribeAutomationExecutionsError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::describe_automation_executions::DescribeAutomationExecutionsError>
for Error
{
fn from(
err: crate::operation::describe_automation_executions::DescribeAutomationExecutionsError,
) -> Self {
match err {
crate::operation::describe_automation_executions::DescribeAutomationExecutionsError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_automation_executions::DescribeAutomationExecutionsError::InvalidFilterKey(inner) => Error::InvalidFilterKey(inner),
crate::operation::describe_automation_executions::DescribeAutomationExecutionsError::InvalidFilterValue(inner) => Error::InvalidFilterValue(inner),
crate::operation::describe_automation_executions::DescribeAutomationExecutionsError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::describe_automation_executions::DescribeAutomationExecutionsError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::describe_automation_step_executions::DescribeAutomationStepExecutionsError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
fn from(err: aws_smithy_http::result::SdkError<crate::operation::describe_automation_step_executions::DescribeAutomationStepExecutionsError, R>) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
.source(err)
.build()
),
}
}
}
impl From<crate::operation::describe_automation_step_executions::DescribeAutomationStepExecutionsError> for Error {
fn from(err: crate::operation::describe_automation_step_executions::DescribeAutomationStepExecutionsError) -> Self {
match err {
crate::operation::describe_automation_step_executions::DescribeAutomationStepExecutionsError::AutomationExecutionNotFoundException(inner) => Error::AutomationExecutionNotFoundException(inner),
crate::operation::describe_automation_step_executions::DescribeAutomationStepExecutionsError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_automation_step_executions::DescribeAutomationStepExecutionsError::InvalidFilterKey(inner) => Error::InvalidFilterKey(inner),
crate::operation::describe_automation_step_executions::DescribeAutomationStepExecutionsError::InvalidFilterValue(inner) => Error::InvalidFilterValue(inner),
crate::operation::describe_automation_step_executions::DescribeAutomationStepExecutionsError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::describe_automation_step_executions::DescribeAutomationStepExecutionsError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::describe_available_patches::DescribeAvailablePatchesError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::describe_available_patches::DescribeAvailablePatchesError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::describe_available_patches::DescribeAvailablePatchesError> for Error {
fn from(
err: crate::operation::describe_available_patches::DescribeAvailablePatchesError,
) -> Self {
match err {
crate::operation::describe_available_patches::DescribeAvailablePatchesError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_available_patches::DescribeAvailablePatchesError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::describe_document::DescribeDocumentError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::describe_document::DescribeDocumentError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::describe_document::DescribeDocumentError> for Error {
fn from(err: crate::operation::describe_document::DescribeDocumentError) -> Self {
match err {
crate::operation::describe_document::DescribeDocumentError::InternalServerError(
inner,
) => Error::InternalServerError(inner),
crate::operation::describe_document::DescribeDocumentError::InvalidDocument(inner) => {
Error::InvalidDocument(inner)
}
crate::operation::describe_document::DescribeDocumentError::InvalidDocumentVersion(
inner,
) => Error::InvalidDocumentVersion(inner),
crate::operation::describe_document::DescribeDocumentError::Unhandled(inner) => {
Error::Unhandled(inner)
}
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::describe_document_permission::DescribeDocumentPermissionError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::describe_document_permission::DescribeDocumentPermissionError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::describe_document_permission::DescribeDocumentPermissionError>
for Error
{
fn from(
err: crate::operation::describe_document_permission::DescribeDocumentPermissionError,
) -> Self {
match err {
crate::operation::describe_document_permission::DescribeDocumentPermissionError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_document_permission::DescribeDocumentPermissionError::InvalidDocument(inner) => Error::InvalidDocument(inner),
crate::operation::describe_document_permission::DescribeDocumentPermissionError::InvalidDocumentOperation(inner) => Error::InvalidDocumentOperation(inner),
crate::operation::describe_document_permission::DescribeDocumentPermissionError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::describe_document_permission::DescribeDocumentPermissionError::InvalidPermissionType(inner) => Error::InvalidPermissionType(inner),
crate::operation::describe_document_permission::DescribeDocumentPermissionError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::describe_effective_instance_associations::DescribeEffectiveInstanceAssociationsError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
fn from(err: aws_smithy_http::result::SdkError<crate::operation::describe_effective_instance_associations::DescribeEffectiveInstanceAssociationsError, R>) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
.source(err)
.build()
),
}
}
}
impl From<crate::operation::describe_effective_instance_associations::DescribeEffectiveInstanceAssociationsError> for Error {
fn from(err: crate::operation::describe_effective_instance_associations::DescribeEffectiveInstanceAssociationsError) -> Self {
match err {
crate::operation::describe_effective_instance_associations::DescribeEffectiveInstanceAssociationsError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_effective_instance_associations::DescribeEffectiveInstanceAssociationsError::InvalidInstanceId(inner) => Error::InvalidInstanceId(inner),
crate::operation::describe_effective_instance_associations::DescribeEffectiveInstanceAssociationsError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::describe_effective_instance_associations::DescribeEffectiveInstanceAssociationsError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::describe_effective_patches_for_patch_baseline::DescribeEffectivePatchesForPatchBaselineError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
fn from(err: aws_smithy_http::result::SdkError<crate::operation::describe_effective_patches_for_patch_baseline::DescribeEffectivePatchesForPatchBaselineError, R>) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
.source(err)
.build()
),
}
}
}
impl From<crate::operation::describe_effective_patches_for_patch_baseline::DescribeEffectivePatchesForPatchBaselineError> for Error {
fn from(err: crate::operation::describe_effective_patches_for_patch_baseline::DescribeEffectivePatchesForPatchBaselineError) -> Self {
match err {
crate::operation::describe_effective_patches_for_patch_baseline::DescribeEffectivePatchesForPatchBaselineError::DoesNotExistException(inner) => Error::DoesNotExistException(inner),
crate::operation::describe_effective_patches_for_patch_baseline::DescribeEffectivePatchesForPatchBaselineError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_effective_patches_for_patch_baseline::DescribeEffectivePatchesForPatchBaselineError::InvalidResourceId(inner) => Error::InvalidResourceId(inner),
crate::operation::describe_effective_patches_for_patch_baseline::DescribeEffectivePatchesForPatchBaselineError::UnsupportedOperatingSystem(inner) => Error::UnsupportedOperatingSystem(inner),
crate::operation::describe_effective_patches_for_patch_baseline::DescribeEffectivePatchesForPatchBaselineError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::describe_instance_associations_status::DescribeInstanceAssociationsStatusError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
fn from(err: aws_smithy_http::result::SdkError<crate::operation::describe_instance_associations_status::DescribeInstanceAssociationsStatusError, R>) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
.source(err)
.build()
),
}
}
}
impl From<crate::operation::describe_instance_associations_status::DescribeInstanceAssociationsStatusError> for Error {
fn from(err: crate::operation::describe_instance_associations_status::DescribeInstanceAssociationsStatusError) -> Self {
match err {
crate::operation::describe_instance_associations_status::DescribeInstanceAssociationsStatusError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_instance_associations_status::DescribeInstanceAssociationsStatusError::InvalidInstanceId(inner) => Error::InvalidInstanceId(inner),
crate::operation::describe_instance_associations_status::DescribeInstanceAssociationsStatusError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::describe_instance_associations_status::DescribeInstanceAssociationsStatusError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::describe_instance_information::DescribeInstanceInformationError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::describe_instance_information::DescribeInstanceInformationError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::describe_instance_information::DescribeInstanceInformationError>
for Error
{
fn from(
err: crate::operation::describe_instance_information::DescribeInstanceInformationError,
) -> Self {
match err {
crate::operation::describe_instance_information::DescribeInstanceInformationError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_instance_information::DescribeInstanceInformationError::InvalidFilterKey(inner) => Error::InvalidFilterKey(inner),
crate::operation::describe_instance_information::DescribeInstanceInformationError::InvalidInstanceId(inner) => Error::InvalidInstanceId(inner),
crate::operation::describe_instance_information::DescribeInstanceInformationError::InvalidInstanceInformationFilterValue(inner) => Error::InvalidInstanceInformationFilterValue(inner),
crate::operation::describe_instance_information::DescribeInstanceInformationError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::describe_instance_information::DescribeInstanceInformationError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::describe_instance_patches::DescribeInstancePatchesError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::describe_instance_patches::DescribeInstancePatchesError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::describe_instance_patches::DescribeInstancePatchesError> for Error {
fn from(
err: crate::operation::describe_instance_patches::DescribeInstancePatchesError,
) -> Self {
match err {
crate::operation::describe_instance_patches::DescribeInstancePatchesError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_instance_patches::DescribeInstancePatchesError::InvalidFilter(inner) => Error::InvalidFilter(inner),
crate::operation::describe_instance_patches::DescribeInstancePatchesError::InvalidInstanceId(inner) => Error::InvalidInstanceId(inner),
crate::operation::describe_instance_patches::DescribeInstancePatchesError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::describe_instance_patches::DescribeInstancePatchesError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::describe_instance_patch_states::DescribeInstancePatchStatesError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::describe_instance_patch_states::DescribeInstancePatchStatesError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::describe_instance_patch_states::DescribeInstancePatchStatesError>
for Error
{
fn from(
err: crate::operation::describe_instance_patch_states::DescribeInstancePatchStatesError,
) -> Self {
match err {
crate::operation::describe_instance_patch_states::DescribeInstancePatchStatesError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_instance_patch_states::DescribeInstancePatchStatesError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::describe_instance_patch_states::DescribeInstancePatchStatesError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::describe_instance_patch_states_for_patch_group::DescribeInstancePatchStatesForPatchGroupError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
fn from(err: aws_smithy_http::result::SdkError<crate::operation::describe_instance_patch_states_for_patch_group::DescribeInstancePatchStatesForPatchGroupError, R>) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
.source(err)
.build()
),
}
}
}
impl From<crate::operation::describe_instance_patch_states_for_patch_group::DescribeInstancePatchStatesForPatchGroupError> for Error {
fn from(err: crate::operation::describe_instance_patch_states_for_patch_group::DescribeInstancePatchStatesForPatchGroupError) -> Self {
match err {
crate::operation::describe_instance_patch_states_for_patch_group::DescribeInstancePatchStatesForPatchGroupError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_instance_patch_states_for_patch_group::DescribeInstancePatchStatesForPatchGroupError::InvalidFilter(inner) => Error::InvalidFilter(inner),
crate::operation::describe_instance_patch_states_for_patch_group::DescribeInstancePatchStatesForPatchGroupError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::describe_instance_patch_states_for_patch_group::DescribeInstancePatchStatesForPatchGroupError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::describe_inventory_deletions::DescribeInventoryDeletionsError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::describe_inventory_deletions::DescribeInventoryDeletionsError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::describe_inventory_deletions::DescribeInventoryDeletionsError>
for Error
{
fn from(
err: crate::operation::describe_inventory_deletions::DescribeInventoryDeletionsError,
) -> Self {
match err {
crate::operation::describe_inventory_deletions::DescribeInventoryDeletionsError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_inventory_deletions::DescribeInventoryDeletionsError::InvalidDeletionIdException(inner) => Error::InvalidDeletionIdException(inner),
crate::operation::describe_inventory_deletions::DescribeInventoryDeletionsError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::describe_inventory_deletions::DescribeInventoryDeletionsError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::describe_maintenance_window_executions::DescribeMaintenanceWindowExecutionsError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
fn from(err: aws_smithy_http::result::SdkError<crate::operation::describe_maintenance_window_executions::DescribeMaintenanceWindowExecutionsError, R>) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
.source(err)
.build()
),
}
}
}
impl From<crate::operation::describe_maintenance_window_executions::DescribeMaintenanceWindowExecutionsError> for Error {
fn from(err: crate::operation::describe_maintenance_window_executions::DescribeMaintenanceWindowExecutionsError) -> Self {
match err {
crate::operation::describe_maintenance_window_executions::DescribeMaintenanceWindowExecutionsError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_maintenance_window_executions::DescribeMaintenanceWindowExecutionsError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::describe_maintenance_window_execution_task_invocations::DescribeMaintenanceWindowExecutionTaskInvocationsError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
fn from(err: aws_smithy_http::result::SdkError<crate::operation::describe_maintenance_window_execution_task_invocations::DescribeMaintenanceWindowExecutionTaskInvocationsError, R>) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
.source(err)
.build()
),
}
}
}
impl From<crate::operation::describe_maintenance_window_execution_task_invocations::DescribeMaintenanceWindowExecutionTaskInvocationsError> for Error {
fn from(err: crate::operation::describe_maintenance_window_execution_task_invocations::DescribeMaintenanceWindowExecutionTaskInvocationsError) -> Self {
match err {
crate::operation::describe_maintenance_window_execution_task_invocations::DescribeMaintenanceWindowExecutionTaskInvocationsError::DoesNotExistException(inner) => Error::DoesNotExistException(inner),
crate::operation::describe_maintenance_window_execution_task_invocations::DescribeMaintenanceWindowExecutionTaskInvocationsError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_maintenance_window_execution_task_invocations::DescribeMaintenanceWindowExecutionTaskInvocationsError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::describe_maintenance_window_execution_tasks::DescribeMaintenanceWindowExecutionTasksError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
fn from(err: aws_smithy_http::result::SdkError<crate::operation::describe_maintenance_window_execution_tasks::DescribeMaintenanceWindowExecutionTasksError, R>) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
.source(err)
.build()
),
}
}
}
impl From<crate::operation::describe_maintenance_window_execution_tasks::DescribeMaintenanceWindowExecutionTasksError> for Error {
fn from(err: crate::operation::describe_maintenance_window_execution_tasks::DescribeMaintenanceWindowExecutionTasksError) -> Self {
match err {
crate::operation::describe_maintenance_window_execution_tasks::DescribeMaintenanceWindowExecutionTasksError::DoesNotExistException(inner) => Error::DoesNotExistException(inner),
crate::operation::describe_maintenance_window_execution_tasks::DescribeMaintenanceWindowExecutionTasksError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_maintenance_window_execution_tasks::DescribeMaintenanceWindowExecutionTasksError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::describe_maintenance_windows::DescribeMaintenanceWindowsError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::describe_maintenance_windows::DescribeMaintenanceWindowsError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::describe_maintenance_windows::DescribeMaintenanceWindowsError>
for Error
{
fn from(
err: crate::operation::describe_maintenance_windows::DescribeMaintenanceWindowsError,
) -> Self {
match err {
crate::operation::describe_maintenance_windows::DescribeMaintenanceWindowsError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_maintenance_windows::DescribeMaintenanceWindowsError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::describe_maintenance_window_schedule::DescribeMaintenanceWindowScheduleError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
fn from(err: aws_smithy_http::result::SdkError<crate::operation::describe_maintenance_window_schedule::DescribeMaintenanceWindowScheduleError, R>) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
.source(err)
.build()
),
}
}
}
impl From<crate::operation::describe_maintenance_window_schedule::DescribeMaintenanceWindowScheduleError> for Error {
fn from(err: crate::operation::describe_maintenance_window_schedule::DescribeMaintenanceWindowScheduleError) -> Self {
match err {
crate::operation::describe_maintenance_window_schedule::DescribeMaintenanceWindowScheduleError::DoesNotExistException(inner) => Error::DoesNotExistException(inner),
crate::operation::describe_maintenance_window_schedule::DescribeMaintenanceWindowScheduleError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_maintenance_window_schedule::DescribeMaintenanceWindowScheduleError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::describe_maintenance_windows_for_target::DescribeMaintenanceWindowsForTargetError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
fn from(err: aws_smithy_http::result::SdkError<crate::operation::describe_maintenance_windows_for_target::DescribeMaintenanceWindowsForTargetError, R>) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
.source(err)
.build()
),
}
}
}
impl From<crate::operation::describe_maintenance_windows_for_target::DescribeMaintenanceWindowsForTargetError> for Error {
fn from(err: crate::operation::describe_maintenance_windows_for_target::DescribeMaintenanceWindowsForTargetError) -> Self {
match err {
crate::operation::describe_maintenance_windows_for_target::DescribeMaintenanceWindowsForTargetError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_maintenance_windows_for_target::DescribeMaintenanceWindowsForTargetError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::describe_maintenance_window_targets::DescribeMaintenanceWindowTargetsError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
fn from(err: aws_smithy_http::result::SdkError<crate::operation::describe_maintenance_window_targets::DescribeMaintenanceWindowTargetsError, R>) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
.source(err)
.build()
),
}
}
}
impl From<crate::operation::describe_maintenance_window_targets::DescribeMaintenanceWindowTargetsError> for Error {
fn from(err: crate::operation::describe_maintenance_window_targets::DescribeMaintenanceWindowTargetsError) -> Self {
match err {
crate::operation::describe_maintenance_window_targets::DescribeMaintenanceWindowTargetsError::DoesNotExistException(inner) => Error::DoesNotExistException(inner),
crate::operation::describe_maintenance_window_targets::DescribeMaintenanceWindowTargetsError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_maintenance_window_targets::DescribeMaintenanceWindowTargetsError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::describe_maintenance_window_tasks::DescribeMaintenanceWindowTasksError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
fn from(err: aws_smithy_http::result::SdkError<crate::operation::describe_maintenance_window_tasks::DescribeMaintenanceWindowTasksError, R>) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
.source(err)
.build()
),
}
}
}
impl From<crate::operation::describe_maintenance_window_tasks::DescribeMaintenanceWindowTasksError>
for Error
{
fn from(
err: crate::operation::describe_maintenance_window_tasks::DescribeMaintenanceWindowTasksError,
) -> Self {
match err {
crate::operation::describe_maintenance_window_tasks::DescribeMaintenanceWindowTasksError::DoesNotExistException(inner) => Error::DoesNotExistException(inner),
crate::operation::describe_maintenance_window_tasks::DescribeMaintenanceWindowTasksError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_maintenance_window_tasks::DescribeMaintenanceWindowTasksError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::describe_ops_items::DescribeOpsItemsError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::describe_ops_items::DescribeOpsItemsError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::describe_ops_items::DescribeOpsItemsError> for Error {
fn from(err: crate::operation::describe_ops_items::DescribeOpsItemsError) -> Self {
match err {
crate::operation::describe_ops_items::DescribeOpsItemsError::InternalServerError(
inner,
) => Error::InternalServerError(inner),
crate::operation::describe_ops_items::DescribeOpsItemsError::Unhandled(inner) => {
Error::Unhandled(inner)
}
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::describe_parameters::DescribeParametersError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::describe_parameters::DescribeParametersError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::describe_parameters::DescribeParametersError> for Error {
fn from(err: crate::operation::describe_parameters::DescribeParametersError) -> Self {
match err {
crate::operation::describe_parameters::DescribeParametersError::InternalServerError(
inner,
) => Error::InternalServerError(inner),
crate::operation::describe_parameters::DescribeParametersError::InvalidFilterKey(
inner,
) => Error::InvalidFilterKey(inner),
crate::operation::describe_parameters::DescribeParametersError::InvalidFilterOption(
inner,
) => Error::InvalidFilterOption(inner),
crate::operation::describe_parameters::DescribeParametersError::InvalidFilterValue(
inner,
) => Error::InvalidFilterValue(inner),
crate::operation::describe_parameters::DescribeParametersError::InvalidNextToken(
inner,
) => Error::InvalidNextToken(inner),
crate::operation::describe_parameters::DescribeParametersError::Unhandled(inner) => {
Error::Unhandled(inner)
}
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::describe_patch_baselines::DescribePatchBaselinesError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::describe_patch_baselines::DescribePatchBaselinesError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::describe_patch_baselines::DescribePatchBaselinesError> for Error {
fn from(err: crate::operation::describe_patch_baselines::DescribePatchBaselinesError) -> Self {
match err {
crate::operation::describe_patch_baselines::DescribePatchBaselinesError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_patch_baselines::DescribePatchBaselinesError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::describe_patch_groups::DescribePatchGroupsError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::describe_patch_groups::DescribePatchGroupsError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::describe_patch_groups::DescribePatchGroupsError> for Error {
fn from(err: crate::operation::describe_patch_groups::DescribePatchGroupsError) -> Self {
match err {
crate::operation::describe_patch_groups::DescribePatchGroupsError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_patch_groups::DescribePatchGroupsError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::describe_patch_group_state::DescribePatchGroupStateError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::describe_patch_group_state::DescribePatchGroupStateError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::describe_patch_group_state::DescribePatchGroupStateError> for Error {
fn from(
err: crate::operation::describe_patch_group_state::DescribePatchGroupStateError,
) -> Self {
match err {
crate::operation::describe_patch_group_state::DescribePatchGroupStateError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_patch_group_state::DescribePatchGroupStateError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::describe_patch_group_state::DescribePatchGroupStateError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::describe_patch_properties::DescribePatchPropertiesError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::describe_patch_properties::DescribePatchPropertiesError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::describe_patch_properties::DescribePatchPropertiesError> for Error {
fn from(
err: crate::operation::describe_patch_properties::DescribePatchPropertiesError,
) -> Self {
match err {
crate::operation::describe_patch_properties::DescribePatchPropertiesError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::describe_patch_properties::DescribePatchPropertiesError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::describe_sessions::DescribeSessionsError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::describe_sessions::DescribeSessionsError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::describe_sessions::DescribeSessionsError> for Error {
fn from(err: crate::operation::describe_sessions::DescribeSessionsError) -> Self {
match err {
crate::operation::describe_sessions::DescribeSessionsError::InternalServerError(
inner,
) => Error::InternalServerError(inner),
crate::operation::describe_sessions::DescribeSessionsError::InvalidFilterKey(inner) => {
Error::InvalidFilterKey(inner)
}
crate::operation::describe_sessions::DescribeSessionsError::InvalidNextToken(inner) => {
Error::InvalidNextToken(inner)
}
crate::operation::describe_sessions::DescribeSessionsError::Unhandled(inner) => {
Error::Unhandled(inner)
}
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::disassociate_ops_item_related_item::DisassociateOpsItemRelatedItemError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
fn from(err: aws_smithy_http::result::SdkError<crate::operation::disassociate_ops_item_related_item::DisassociateOpsItemRelatedItemError, R>) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
.source(err)
.build()
),
}
}
}
impl From<crate::operation::disassociate_ops_item_related_item::DisassociateOpsItemRelatedItemError>
for Error
{
fn from(
err: crate::operation::disassociate_ops_item_related_item::DisassociateOpsItemRelatedItemError,
) -> Self {
match err {
crate::operation::disassociate_ops_item_related_item::DisassociateOpsItemRelatedItemError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::disassociate_ops_item_related_item::DisassociateOpsItemRelatedItemError::OpsItemInvalidParameterException(inner) => Error::OpsItemInvalidParameterException(inner),
crate::operation::disassociate_ops_item_related_item::DisassociateOpsItemRelatedItemError::OpsItemNotFoundException(inner) => Error::OpsItemNotFoundException(inner),
crate::operation::disassociate_ops_item_related_item::DisassociateOpsItemRelatedItemError::OpsItemRelatedItemAssociationNotFoundException(inner) => Error::OpsItemRelatedItemAssociationNotFoundException(inner),
crate::operation::disassociate_ops_item_related_item::DisassociateOpsItemRelatedItemError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::get_automation_execution::GetAutomationExecutionError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::get_automation_execution::GetAutomationExecutionError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::get_automation_execution::GetAutomationExecutionError> for Error {
fn from(err: crate::operation::get_automation_execution::GetAutomationExecutionError) -> Self {
match err {
crate::operation::get_automation_execution::GetAutomationExecutionError::AutomationExecutionNotFoundException(inner) => Error::AutomationExecutionNotFoundException(inner),
crate::operation::get_automation_execution::GetAutomationExecutionError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::get_automation_execution::GetAutomationExecutionError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::get_calendar_state::GetCalendarStateError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::get_calendar_state::GetCalendarStateError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::get_calendar_state::GetCalendarStateError> for Error {
fn from(err: crate::operation::get_calendar_state::GetCalendarStateError) -> Self {
match err {
crate::operation::get_calendar_state::GetCalendarStateError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::get_calendar_state::GetCalendarStateError::InvalidDocument(inner) => Error::InvalidDocument(inner),
crate::operation::get_calendar_state::GetCalendarStateError::InvalidDocumentType(inner) => Error::InvalidDocumentType(inner),
crate::operation::get_calendar_state::GetCalendarStateError::UnsupportedCalendarException(inner) => Error::UnsupportedCalendarException(inner),
crate::operation::get_calendar_state::GetCalendarStateError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::get_command_invocation::GetCommandInvocationError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::get_command_invocation::GetCommandInvocationError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::get_command_invocation::GetCommandInvocationError> for Error {
fn from(err: crate::operation::get_command_invocation::GetCommandInvocationError) -> Self {
match err {
crate::operation::get_command_invocation::GetCommandInvocationError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::get_command_invocation::GetCommandInvocationError::InvalidCommandId(inner) => Error::InvalidCommandId(inner),
crate::operation::get_command_invocation::GetCommandInvocationError::InvalidInstanceId(inner) => Error::InvalidInstanceId(inner),
crate::operation::get_command_invocation::GetCommandInvocationError::InvalidPluginName(inner) => Error::InvalidPluginName(inner),
crate::operation::get_command_invocation::GetCommandInvocationError::InvocationDoesNotExist(inner) => Error::InvocationDoesNotExist(inner),
crate::operation::get_command_invocation::GetCommandInvocationError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::get_connection_status::GetConnectionStatusError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::get_connection_status::GetConnectionStatusError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::get_connection_status::GetConnectionStatusError> for Error {
fn from(err: crate::operation::get_connection_status::GetConnectionStatusError) -> Self {
match err {
crate::operation::get_connection_status::GetConnectionStatusError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::get_connection_status::GetConnectionStatusError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::get_default_patch_baseline::GetDefaultPatchBaselineError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::get_default_patch_baseline::GetDefaultPatchBaselineError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::get_default_patch_baseline::GetDefaultPatchBaselineError> for Error {
fn from(
err: crate::operation::get_default_patch_baseline::GetDefaultPatchBaselineError,
) -> Self {
match err {
crate::operation::get_default_patch_baseline::GetDefaultPatchBaselineError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::get_default_patch_baseline::GetDefaultPatchBaselineError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::get_deployable_patch_snapshot_for_instance::GetDeployablePatchSnapshotForInstanceError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
fn from(err: aws_smithy_http::result::SdkError<crate::operation::get_deployable_patch_snapshot_for_instance::GetDeployablePatchSnapshotForInstanceError, R>) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
.source(err)
.build()
),
}
}
}
impl From<crate::operation::get_deployable_patch_snapshot_for_instance::GetDeployablePatchSnapshotForInstanceError> for Error {
fn from(err: crate::operation::get_deployable_patch_snapshot_for_instance::GetDeployablePatchSnapshotForInstanceError) -> Self {
match err {
crate::operation::get_deployable_patch_snapshot_for_instance::GetDeployablePatchSnapshotForInstanceError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::get_deployable_patch_snapshot_for_instance::GetDeployablePatchSnapshotForInstanceError::UnsupportedFeatureRequiredException(inner) => Error::UnsupportedFeatureRequiredException(inner),
crate::operation::get_deployable_patch_snapshot_for_instance::GetDeployablePatchSnapshotForInstanceError::UnsupportedOperatingSystem(inner) => Error::UnsupportedOperatingSystem(inner),
crate::operation::get_deployable_patch_snapshot_for_instance::GetDeployablePatchSnapshotForInstanceError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::get_document::GetDocumentError, R>>
for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<crate::operation::get_document::GetDocumentError, R>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::get_document::GetDocumentError> for Error {
fn from(err: crate::operation::get_document::GetDocumentError) -> Self {
match err {
crate::operation::get_document::GetDocumentError::InternalServerError(inner) => {
Error::InternalServerError(inner)
}
crate::operation::get_document::GetDocumentError::InvalidDocument(inner) => {
Error::InvalidDocument(inner)
}
crate::operation::get_document::GetDocumentError::InvalidDocumentVersion(inner) => {
Error::InvalidDocumentVersion(inner)
}
crate::operation::get_document::GetDocumentError::Unhandled(inner) => {
Error::Unhandled(inner)
}
}
}
}
impl<R>
From<aws_smithy_http::result::SdkError<crate::operation::get_inventory::GetInventoryError, R>>
for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::get_inventory::GetInventoryError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::get_inventory::GetInventoryError> for Error {
fn from(err: crate::operation::get_inventory::GetInventoryError) -> Self {
match err {
crate::operation::get_inventory::GetInventoryError::InternalServerError(inner) => {
Error::InternalServerError(inner)
}
crate::operation::get_inventory::GetInventoryError::InvalidAggregatorException(
inner,
) => Error::InvalidAggregatorException(inner),
crate::operation::get_inventory::GetInventoryError::InvalidFilter(inner) => {
Error::InvalidFilter(inner)
}
crate::operation::get_inventory::GetInventoryError::InvalidInventoryGroupException(
inner,
) => Error::InvalidInventoryGroupException(inner),
crate::operation::get_inventory::GetInventoryError::InvalidNextToken(inner) => {
Error::InvalidNextToken(inner)
}
crate::operation::get_inventory::GetInventoryError::InvalidResultAttributeException(
inner,
) => Error::InvalidResultAttributeException(inner),
crate::operation::get_inventory::GetInventoryError::InvalidTypeNameException(inner) => {
Error::InvalidTypeNameException(inner)
}
crate::operation::get_inventory::GetInventoryError::Unhandled(inner) => {
Error::Unhandled(inner)
}
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::get_inventory_schema::GetInventorySchemaError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::get_inventory_schema::GetInventorySchemaError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::get_inventory_schema::GetInventorySchemaError> for Error {
fn from(err: crate::operation::get_inventory_schema::GetInventorySchemaError) -> Self {
match err {
crate::operation::get_inventory_schema::GetInventorySchemaError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::get_inventory_schema::GetInventorySchemaError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::get_inventory_schema::GetInventorySchemaError::InvalidTypeNameException(inner) => Error::InvalidTypeNameException(inner),
crate::operation::get_inventory_schema::GetInventorySchemaError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::get_maintenance_window::GetMaintenanceWindowError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::get_maintenance_window::GetMaintenanceWindowError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::get_maintenance_window::GetMaintenanceWindowError> for Error {
fn from(err: crate::operation::get_maintenance_window::GetMaintenanceWindowError) -> Self {
match err {
crate::operation::get_maintenance_window::GetMaintenanceWindowError::DoesNotExistException(inner) => Error::DoesNotExistException(inner),
crate::operation::get_maintenance_window::GetMaintenanceWindowError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::get_maintenance_window::GetMaintenanceWindowError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::get_maintenance_window_execution::GetMaintenanceWindowExecutionError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::get_maintenance_window_execution::GetMaintenanceWindowExecutionError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::get_maintenance_window_execution::GetMaintenanceWindowExecutionError>
for Error
{
fn from(
err: crate::operation::get_maintenance_window_execution::GetMaintenanceWindowExecutionError,
) -> Self {
match err {
crate::operation::get_maintenance_window_execution::GetMaintenanceWindowExecutionError::DoesNotExistException(inner) => Error::DoesNotExistException(inner),
crate::operation::get_maintenance_window_execution::GetMaintenanceWindowExecutionError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::get_maintenance_window_execution::GetMaintenanceWindowExecutionError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::get_maintenance_window_execution_task::GetMaintenanceWindowExecutionTaskError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
fn from(err: aws_smithy_http::result::SdkError<crate::operation::get_maintenance_window_execution_task::GetMaintenanceWindowExecutionTaskError, R>) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
.source(err)
.build()
),
}
}
}
impl From<crate::operation::get_maintenance_window_execution_task::GetMaintenanceWindowExecutionTaskError> for Error {
fn from(err: crate::operation::get_maintenance_window_execution_task::GetMaintenanceWindowExecutionTaskError) -> Self {
match err {
crate::operation::get_maintenance_window_execution_task::GetMaintenanceWindowExecutionTaskError::DoesNotExistException(inner) => Error::DoesNotExistException(inner),
crate::operation::get_maintenance_window_execution_task::GetMaintenanceWindowExecutionTaskError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::get_maintenance_window_execution_task::GetMaintenanceWindowExecutionTaskError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::get_maintenance_window_execution_task_invocation::GetMaintenanceWindowExecutionTaskInvocationError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
fn from(err: aws_smithy_http::result::SdkError<crate::operation::get_maintenance_window_execution_task_invocation::GetMaintenanceWindowExecutionTaskInvocationError, R>) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
.source(err)
.build()
),
}
}
}
impl From<crate::operation::get_maintenance_window_execution_task_invocation::GetMaintenanceWindowExecutionTaskInvocationError> for Error {
fn from(err: crate::operation::get_maintenance_window_execution_task_invocation::GetMaintenanceWindowExecutionTaskInvocationError) -> Self {
match err {
crate::operation::get_maintenance_window_execution_task_invocation::GetMaintenanceWindowExecutionTaskInvocationError::DoesNotExistException(inner) => Error::DoesNotExistException(inner),
crate::operation::get_maintenance_window_execution_task_invocation::GetMaintenanceWindowExecutionTaskInvocationError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::get_maintenance_window_execution_task_invocation::GetMaintenanceWindowExecutionTaskInvocationError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::get_maintenance_window_task::GetMaintenanceWindowTaskError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::get_maintenance_window_task::GetMaintenanceWindowTaskError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::get_maintenance_window_task::GetMaintenanceWindowTaskError> for Error {
fn from(
err: crate::operation::get_maintenance_window_task::GetMaintenanceWindowTaskError,
) -> Self {
match err {
crate::operation::get_maintenance_window_task::GetMaintenanceWindowTaskError::DoesNotExistException(inner) => Error::DoesNotExistException(inner),
crate::operation::get_maintenance_window_task::GetMaintenanceWindowTaskError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::get_maintenance_window_task::GetMaintenanceWindowTaskError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::get_ops_item::GetOpsItemError, R>>
for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<crate::operation::get_ops_item::GetOpsItemError, R>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::get_ops_item::GetOpsItemError> for Error {
fn from(err: crate::operation::get_ops_item::GetOpsItemError) -> Self {
match err {
crate::operation::get_ops_item::GetOpsItemError::InternalServerError(inner) => {
Error::InternalServerError(inner)
}
crate::operation::get_ops_item::GetOpsItemError::OpsItemAccessDeniedException(
inner,
) => Error::OpsItemAccessDeniedException(inner),
crate::operation::get_ops_item::GetOpsItemError::OpsItemNotFoundException(inner) => {
Error::OpsItemNotFoundException(inner)
}
crate::operation::get_ops_item::GetOpsItemError::Unhandled(inner) => {
Error::Unhandled(inner)
}
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::get_ops_metadata::GetOpsMetadataError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::get_ops_metadata::GetOpsMetadataError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::get_ops_metadata::GetOpsMetadataError> for Error {
fn from(err: crate::operation::get_ops_metadata::GetOpsMetadataError) -> Self {
match err {
crate::operation::get_ops_metadata::GetOpsMetadataError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::get_ops_metadata::GetOpsMetadataError::OpsMetadataInvalidArgumentException(inner) => Error::OpsMetadataInvalidArgumentException(inner),
crate::operation::get_ops_metadata::GetOpsMetadataError::OpsMetadataNotFoundException(inner) => Error::OpsMetadataNotFoundException(inner),
crate::operation::get_ops_metadata::GetOpsMetadataError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<crate::operation::get_ops_summary::GetOpsSummaryError, R>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::get_ops_summary::GetOpsSummaryError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::get_ops_summary::GetOpsSummaryError> for Error {
fn from(err: crate::operation::get_ops_summary::GetOpsSummaryError) -> Self {
match err {
crate::operation::get_ops_summary::GetOpsSummaryError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::get_ops_summary::GetOpsSummaryError::InvalidAggregatorException(inner) => Error::InvalidAggregatorException(inner),
crate::operation::get_ops_summary::GetOpsSummaryError::InvalidFilter(inner) => Error::InvalidFilter(inner),
crate::operation::get_ops_summary::GetOpsSummaryError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::get_ops_summary::GetOpsSummaryError::InvalidTypeNameException(inner) => Error::InvalidTypeNameException(inner),
crate::operation::get_ops_summary::GetOpsSummaryError::ResourceDataSyncNotFoundException(inner) => Error::ResourceDataSyncNotFoundException(inner),
crate::operation::get_ops_summary::GetOpsSummaryError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<aws_smithy_http::result::SdkError<crate::operation::get_parameter::GetParameterError, R>>
for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::get_parameter::GetParameterError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::get_parameter::GetParameterError> for Error {
fn from(err: crate::operation::get_parameter::GetParameterError) -> Self {
match err {
crate::operation::get_parameter::GetParameterError::InternalServerError(inner) => {
Error::InternalServerError(inner)
}
crate::operation::get_parameter::GetParameterError::InvalidKeyId(inner) => {
Error::InvalidKeyId(inner)
}
crate::operation::get_parameter::GetParameterError::ParameterNotFound(inner) => {
Error::ParameterNotFound(inner)
}
crate::operation::get_parameter::GetParameterError::ParameterVersionNotFound(inner) => {
Error::ParameterVersionNotFound(inner)
}
crate::operation::get_parameter::GetParameterError::Unhandled(inner) => {
Error::Unhandled(inner)
}
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::get_parameter_history::GetParameterHistoryError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::get_parameter_history::GetParameterHistoryError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::get_parameter_history::GetParameterHistoryError> for Error {
fn from(err: crate::operation::get_parameter_history::GetParameterHistoryError) -> Self {
match err {
crate::operation::get_parameter_history::GetParameterHistoryError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::get_parameter_history::GetParameterHistoryError::InvalidKeyId(inner) => Error::InvalidKeyId(inner),
crate::operation::get_parameter_history::GetParameterHistoryError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::get_parameter_history::GetParameterHistoryError::ParameterNotFound(inner) => Error::ParameterNotFound(inner),
crate::operation::get_parameter_history::GetParameterHistoryError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<aws_smithy_http::result::SdkError<crate::operation::get_parameters::GetParametersError, R>>
for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::get_parameters::GetParametersError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::get_parameters::GetParametersError> for Error {
fn from(err: crate::operation::get_parameters::GetParametersError) -> Self {
match err {
crate::operation::get_parameters::GetParametersError::InternalServerError(inner) => {
Error::InternalServerError(inner)
}
crate::operation::get_parameters::GetParametersError::InvalidKeyId(inner) => {
Error::InvalidKeyId(inner)
}
crate::operation::get_parameters::GetParametersError::Unhandled(inner) => {
Error::Unhandled(inner)
}
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::get_parameters_by_path::GetParametersByPathError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::get_parameters_by_path::GetParametersByPathError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::get_parameters_by_path::GetParametersByPathError> for Error {
fn from(err: crate::operation::get_parameters_by_path::GetParametersByPathError) -> Self {
match err {
crate::operation::get_parameters_by_path::GetParametersByPathError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::get_parameters_by_path::GetParametersByPathError::InvalidFilterKey(inner) => Error::InvalidFilterKey(inner),
crate::operation::get_parameters_by_path::GetParametersByPathError::InvalidFilterOption(inner) => Error::InvalidFilterOption(inner),
crate::operation::get_parameters_by_path::GetParametersByPathError::InvalidFilterValue(inner) => Error::InvalidFilterValue(inner),
crate::operation::get_parameters_by_path::GetParametersByPathError::InvalidKeyId(inner) => Error::InvalidKeyId(inner),
crate::operation::get_parameters_by_path::GetParametersByPathError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::get_parameters_by_path::GetParametersByPathError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::get_patch_baseline::GetPatchBaselineError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::get_patch_baseline::GetPatchBaselineError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::get_patch_baseline::GetPatchBaselineError> for Error {
fn from(err: crate::operation::get_patch_baseline::GetPatchBaselineError) -> Self {
match err {
crate::operation::get_patch_baseline::GetPatchBaselineError::DoesNotExistException(
inner,
) => Error::DoesNotExistException(inner),
crate::operation::get_patch_baseline::GetPatchBaselineError::InternalServerError(
inner,
) => Error::InternalServerError(inner),
crate::operation::get_patch_baseline::GetPatchBaselineError::InvalidResourceId(
inner,
) => Error::InvalidResourceId(inner),
crate::operation::get_patch_baseline::GetPatchBaselineError::Unhandled(inner) => {
Error::Unhandled(inner)
}
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::get_patch_baseline_for_patch_group::GetPatchBaselineForPatchGroupError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
fn from(err: aws_smithy_http::result::SdkError<crate::operation::get_patch_baseline_for_patch_group::GetPatchBaselineForPatchGroupError, R>) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
.source(err)
.build()
),
}
}
}
impl From<crate::operation::get_patch_baseline_for_patch_group::GetPatchBaselineForPatchGroupError>
for Error
{
fn from(
err: crate::operation::get_patch_baseline_for_patch_group::GetPatchBaselineForPatchGroupError,
) -> Self {
match err {
crate::operation::get_patch_baseline_for_patch_group::GetPatchBaselineForPatchGroupError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::get_patch_baseline_for_patch_group::GetPatchBaselineForPatchGroupError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::get_resource_policies::GetResourcePoliciesError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::get_resource_policies::GetResourcePoliciesError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::get_resource_policies::GetResourcePoliciesError> for Error {
fn from(err: crate::operation::get_resource_policies::GetResourcePoliciesError) -> Self {
match err {
crate::operation::get_resource_policies::GetResourcePoliciesError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::get_resource_policies::GetResourcePoliciesError::ResourcePolicyInvalidParameterException(inner) => Error::ResourcePolicyInvalidParameterException(inner),
crate::operation::get_resource_policies::GetResourcePoliciesError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::get_service_setting::GetServiceSettingError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::get_service_setting::GetServiceSettingError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::get_service_setting::GetServiceSettingError> for Error {
fn from(err: crate::operation::get_service_setting::GetServiceSettingError) -> Self {
match err {
crate::operation::get_service_setting::GetServiceSettingError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::get_service_setting::GetServiceSettingError::ServiceSettingNotFound(inner) => Error::ServiceSettingNotFound(inner),
crate::operation::get_service_setting::GetServiceSettingError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::label_parameter_version::LabelParameterVersionError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::label_parameter_version::LabelParameterVersionError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::label_parameter_version::LabelParameterVersionError> for Error {
fn from(err: crate::operation::label_parameter_version::LabelParameterVersionError) -> Self {
match err {
crate::operation::label_parameter_version::LabelParameterVersionError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::label_parameter_version::LabelParameterVersionError::ParameterNotFound(inner) => Error::ParameterNotFound(inner),
crate::operation::label_parameter_version::LabelParameterVersionError::ParameterVersionLabelLimitExceeded(inner) => Error::ParameterVersionLabelLimitExceeded(inner),
crate::operation::label_parameter_version::LabelParameterVersionError::ParameterVersionNotFound(inner) => Error::ParameterVersionNotFound(inner),
crate::operation::label_parameter_version::LabelParameterVersionError::TooManyUpdates(inner) => Error::TooManyUpdates(inner),
crate::operation::label_parameter_version::LabelParameterVersionError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::list_associations::ListAssociationsError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::list_associations::ListAssociationsError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::list_associations::ListAssociationsError> for Error {
fn from(err: crate::operation::list_associations::ListAssociationsError) -> Self {
match err {
crate::operation::list_associations::ListAssociationsError::InternalServerError(
inner,
) => Error::InternalServerError(inner),
crate::operation::list_associations::ListAssociationsError::InvalidNextToken(inner) => {
Error::InvalidNextToken(inner)
}
crate::operation::list_associations::ListAssociationsError::Unhandled(inner) => {
Error::Unhandled(inner)
}
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::list_association_versions::ListAssociationVersionsError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::list_association_versions::ListAssociationVersionsError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::list_association_versions::ListAssociationVersionsError> for Error {
fn from(
err: crate::operation::list_association_versions::ListAssociationVersionsError,
) -> Self {
match err {
crate::operation::list_association_versions::ListAssociationVersionsError::AssociationDoesNotExist(inner) => Error::AssociationDoesNotExist(inner),
crate::operation::list_association_versions::ListAssociationVersionsError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::list_association_versions::ListAssociationVersionsError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::list_association_versions::ListAssociationVersionsError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::list_command_invocations::ListCommandInvocationsError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::list_command_invocations::ListCommandInvocationsError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::list_command_invocations::ListCommandInvocationsError> for Error {
fn from(err: crate::operation::list_command_invocations::ListCommandInvocationsError) -> Self {
match err {
crate::operation::list_command_invocations::ListCommandInvocationsError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::list_command_invocations::ListCommandInvocationsError::InvalidCommandId(inner) => Error::InvalidCommandId(inner),
crate::operation::list_command_invocations::ListCommandInvocationsError::InvalidFilterKey(inner) => Error::InvalidFilterKey(inner),
crate::operation::list_command_invocations::ListCommandInvocationsError::InvalidInstanceId(inner) => Error::InvalidInstanceId(inner),
crate::operation::list_command_invocations::ListCommandInvocationsError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::list_command_invocations::ListCommandInvocationsError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<aws_smithy_http::result::SdkError<crate::operation::list_commands::ListCommandsError, R>>
for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::list_commands::ListCommandsError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::list_commands::ListCommandsError> for Error {
fn from(err: crate::operation::list_commands::ListCommandsError) -> Self {
match err {
crate::operation::list_commands::ListCommandsError::InternalServerError(inner) => {
Error::InternalServerError(inner)
}
crate::operation::list_commands::ListCommandsError::InvalidCommandId(inner) => {
Error::InvalidCommandId(inner)
}
crate::operation::list_commands::ListCommandsError::InvalidFilterKey(inner) => {
Error::InvalidFilterKey(inner)
}
crate::operation::list_commands::ListCommandsError::InvalidInstanceId(inner) => {
Error::InvalidInstanceId(inner)
}
crate::operation::list_commands::ListCommandsError::InvalidNextToken(inner) => {
Error::InvalidNextToken(inner)
}
crate::operation::list_commands::ListCommandsError::Unhandled(inner) => {
Error::Unhandled(inner)
}
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::list_compliance_items::ListComplianceItemsError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::list_compliance_items::ListComplianceItemsError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::list_compliance_items::ListComplianceItemsError> for Error {
fn from(err: crate::operation::list_compliance_items::ListComplianceItemsError) -> Self {
match err {
crate::operation::list_compliance_items::ListComplianceItemsError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::list_compliance_items::ListComplianceItemsError::InvalidFilter(inner) => Error::InvalidFilter(inner),
crate::operation::list_compliance_items::ListComplianceItemsError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::list_compliance_items::ListComplianceItemsError::InvalidResourceId(inner) => Error::InvalidResourceId(inner),
crate::operation::list_compliance_items::ListComplianceItemsError::InvalidResourceType(inner) => Error::InvalidResourceType(inner),
crate::operation::list_compliance_items::ListComplianceItemsError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::list_compliance_summaries::ListComplianceSummariesError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::list_compliance_summaries::ListComplianceSummariesError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::list_compliance_summaries::ListComplianceSummariesError> for Error {
fn from(
err: crate::operation::list_compliance_summaries::ListComplianceSummariesError,
) -> Self {
match err {
crate::operation::list_compliance_summaries::ListComplianceSummariesError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::list_compliance_summaries::ListComplianceSummariesError::InvalidFilter(inner) => Error::InvalidFilter(inner),
crate::operation::list_compliance_summaries::ListComplianceSummariesError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::list_compliance_summaries::ListComplianceSummariesError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::list_document_metadata_history::ListDocumentMetadataHistoryError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::list_document_metadata_history::ListDocumentMetadataHistoryError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::list_document_metadata_history::ListDocumentMetadataHistoryError>
for Error
{
fn from(
err: crate::operation::list_document_metadata_history::ListDocumentMetadataHistoryError,
) -> Self {
match err {
crate::operation::list_document_metadata_history::ListDocumentMetadataHistoryError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::list_document_metadata_history::ListDocumentMetadataHistoryError::InvalidDocument(inner) => Error::InvalidDocument(inner),
crate::operation::list_document_metadata_history::ListDocumentMetadataHistoryError::InvalidDocumentVersion(inner) => Error::InvalidDocumentVersion(inner),
crate::operation::list_document_metadata_history::ListDocumentMetadataHistoryError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::list_document_metadata_history::ListDocumentMetadataHistoryError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<aws_smithy_http::result::SdkError<crate::operation::list_documents::ListDocumentsError, R>>
for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::list_documents::ListDocumentsError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::list_documents::ListDocumentsError> for Error {
fn from(err: crate::operation::list_documents::ListDocumentsError) -> Self {
match err {
crate::operation::list_documents::ListDocumentsError::InternalServerError(inner) => {
Error::InternalServerError(inner)
}
crate::operation::list_documents::ListDocumentsError::InvalidFilterKey(inner) => {
Error::InvalidFilterKey(inner)
}
crate::operation::list_documents::ListDocumentsError::InvalidNextToken(inner) => {
Error::InvalidNextToken(inner)
}
crate::operation::list_documents::ListDocumentsError::Unhandled(inner) => {
Error::Unhandled(inner)
}
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::list_document_versions::ListDocumentVersionsError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::list_document_versions::ListDocumentVersionsError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::list_document_versions::ListDocumentVersionsError> for Error {
fn from(err: crate::operation::list_document_versions::ListDocumentVersionsError) -> Self {
match err {
crate::operation::list_document_versions::ListDocumentVersionsError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::list_document_versions::ListDocumentVersionsError::InvalidDocument(inner) => Error::InvalidDocument(inner),
crate::operation::list_document_versions::ListDocumentVersionsError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::list_document_versions::ListDocumentVersionsError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::list_inventory_entries::ListInventoryEntriesError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::list_inventory_entries::ListInventoryEntriesError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::list_inventory_entries::ListInventoryEntriesError> for Error {
fn from(err: crate::operation::list_inventory_entries::ListInventoryEntriesError) -> Self {
match err {
crate::operation::list_inventory_entries::ListInventoryEntriesError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::list_inventory_entries::ListInventoryEntriesError::InvalidFilter(inner) => Error::InvalidFilter(inner),
crate::operation::list_inventory_entries::ListInventoryEntriesError::InvalidInstanceId(inner) => Error::InvalidInstanceId(inner),
crate::operation::list_inventory_entries::ListInventoryEntriesError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::list_inventory_entries::ListInventoryEntriesError::InvalidTypeNameException(inner) => Error::InvalidTypeNameException(inner),
crate::operation::list_inventory_entries::ListInventoryEntriesError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::list_ops_item_events::ListOpsItemEventsError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::list_ops_item_events::ListOpsItemEventsError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::list_ops_item_events::ListOpsItemEventsError> for Error {
fn from(err: crate::operation::list_ops_item_events::ListOpsItemEventsError) -> Self {
match err {
crate::operation::list_ops_item_events::ListOpsItemEventsError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::list_ops_item_events::ListOpsItemEventsError::OpsItemInvalidParameterException(inner) => Error::OpsItemInvalidParameterException(inner),
crate::operation::list_ops_item_events::ListOpsItemEventsError::OpsItemLimitExceededException(inner) => Error::OpsItemLimitExceededException(inner),
crate::operation::list_ops_item_events::ListOpsItemEventsError::OpsItemNotFoundException(inner) => Error::OpsItemNotFoundException(inner),
crate::operation::list_ops_item_events::ListOpsItemEventsError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::list_ops_item_related_items::ListOpsItemRelatedItemsError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::list_ops_item_related_items::ListOpsItemRelatedItemsError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::list_ops_item_related_items::ListOpsItemRelatedItemsError> for Error {
fn from(
err: crate::operation::list_ops_item_related_items::ListOpsItemRelatedItemsError,
) -> Self {
match err {
crate::operation::list_ops_item_related_items::ListOpsItemRelatedItemsError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::list_ops_item_related_items::ListOpsItemRelatedItemsError::OpsItemInvalidParameterException(inner) => Error::OpsItemInvalidParameterException(inner),
crate::operation::list_ops_item_related_items::ListOpsItemRelatedItemsError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::list_ops_metadata::ListOpsMetadataError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::list_ops_metadata::ListOpsMetadataError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::list_ops_metadata::ListOpsMetadataError> for Error {
fn from(err: crate::operation::list_ops_metadata::ListOpsMetadataError) -> Self {
match err {
crate::operation::list_ops_metadata::ListOpsMetadataError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::list_ops_metadata::ListOpsMetadataError::OpsMetadataInvalidArgumentException(inner) => Error::OpsMetadataInvalidArgumentException(inner),
crate::operation::list_ops_metadata::ListOpsMetadataError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::list_resource_compliance_summaries::ListResourceComplianceSummariesError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
fn from(err: aws_smithy_http::result::SdkError<crate::operation::list_resource_compliance_summaries::ListResourceComplianceSummariesError, R>) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
.source(err)
.build()
),
}
}
}
impl
From<crate::operation::list_resource_compliance_summaries::ListResourceComplianceSummariesError>
for Error
{
fn from(
err: crate::operation::list_resource_compliance_summaries::ListResourceComplianceSummariesError,
) -> Self {
match err {
crate::operation::list_resource_compliance_summaries::ListResourceComplianceSummariesError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::list_resource_compliance_summaries::ListResourceComplianceSummariesError::InvalidFilter(inner) => Error::InvalidFilter(inner),
crate::operation::list_resource_compliance_summaries::ListResourceComplianceSummariesError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::list_resource_compliance_summaries::ListResourceComplianceSummariesError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::list_resource_data_sync::ListResourceDataSyncError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::list_resource_data_sync::ListResourceDataSyncError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::list_resource_data_sync::ListResourceDataSyncError> for Error {
fn from(err: crate::operation::list_resource_data_sync::ListResourceDataSyncError) -> Self {
match err {
crate::operation::list_resource_data_sync::ListResourceDataSyncError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::list_resource_data_sync::ListResourceDataSyncError::InvalidNextToken(inner) => Error::InvalidNextToken(inner),
crate::operation::list_resource_data_sync::ListResourceDataSyncError::ResourceDataSyncInvalidConfigurationException(inner) => Error::ResourceDataSyncInvalidConfigurationException(inner),
crate::operation::list_resource_data_sync::ListResourceDataSyncError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::list_tags_for_resource::ListTagsForResourceError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::list_tags_for_resource::ListTagsForResourceError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::list_tags_for_resource::ListTagsForResourceError> for Error {
fn from(err: crate::operation::list_tags_for_resource::ListTagsForResourceError) -> Self {
match err {
crate::operation::list_tags_for_resource::ListTagsForResourceError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::list_tags_for_resource::ListTagsForResourceError::InvalidResourceId(inner) => Error::InvalidResourceId(inner),
crate::operation::list_tags_for_resource::ListTagsForResourceError::InvalidResourceType(inner) => Error::InvalidResourceType(inner),
crate::operation::list_tags_for_resource::ListTagsForResourceError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::modify_document_permission::ModifyDocumentPermissionError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::modify_document_permission::ModifyDocumentPermissionError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::modify_document_permission::ModifyDocumentPermissionError> for Error {
fn from(
err: crate::operation::modify_document_permission::ModifyDocumentPermissionError,
) -> Self {
match err {
crate::operation::modify_document_permission::ModifyDocumentPermissionError::DocumentLimitExceeded(inner) => Error::DocumentLimitExceeded(inner),
crate::operation::modify_document_permission::ModifyDocumentPermissionError::DocumentPermissionLimit(inner) => Error::DocumentPermissionLimit(inner),
crate::operation::modify_document_permission::ModifyDocumentPermissionError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::modify_document_permission::ModifyDocumentPermissionError::InvalidDocument(inner) => Error::InvalidDocument(inner),
crate::operation::modify_document_permission::ModifyDocumentPermissionError::InvalidPermissionType(inner) => Error::InvalidPermissionType(inner),
crate::operation::modify_document_permission::ModifyDocumentPermissionError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::put_compliance_items::PutComplianceItemsError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::put_compliance_items::PutComplianceItemsError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::put_compliance_items::PutComplianceItemsError> for Error {
fn from(err: crate::operation::put_compliance_items::PutComplianceItemsError) -> Self {
match err {
crate::operation::put_compliance_items::PutComplianceItemsError::ComplianceTypeCountLimitExceededException(inner) => Error::ComplianceTypeCountLimitExceededException(inner),
crate::operation::put_compliance_items::PutComplianceItemsError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::put_compliance_items::PutComplianceItemsError::InvalidItemContentException(inner) => Error::InvalidItemContentException(inner),
crate::operation::put_compliance_items::PutComplianceItemsError::InvalidResourceId(inner) => Error::InvalidResourceId(inner),
crate::operation::put_compliance_items::PutComplianceItemsError::InvalidResourceType(inner) => Error::InvalidResourceType(inner),
crate::operation::put_compliance_items::PutComplianceItemsError::ItemSizeLimitExceededException(inner) => Error::ItemSizeLimitExceededException(inner),
crate::operation::put_compliance_items::PutComplianceItemsError::TotalSizeLimitExceededException(inner) => Error::TotalSizeLimitExceededException(inner),
crate::operation::put_compliance_items::PutComplianceItemsError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<aws_smithy_http::result::SdkError<crate::operation::put_inventory::PutInventoryError, R>>
for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::put_inventory::PutInventoryError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::put_inventory::PutInventoryError> for Error {
fn from(err: crate::operation::put_inventory::PutInventoryError) -> Self {
match err {
crate::operation::put_inventory::PutInventoryError::CustomSchemaCountLimitExceededException(inner) => Error::CustomSchemaCountLimitExceededException(inner),
crate::operation::put_inventory::PutInventoryError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::put_inventory::PutInventoryError::InvalidInstanceId(inner) => Error::InvalidInstanceId(inner),
crate::operation::put_inventory::PutInventoryError::InvalidInventoryItemContextException(inner) => Error::InvalidInventoryItemContextException(inner),
crate::operation::put_inventory::PutInventoryError::InvalidItemContentException(inner) => Error::InvalidItemContentException(inner),
crate::operation::put_inventory::PutInventoryError::InvalidTypeNameException(inner) => Error::InvalidTypeNameException(inner),
crate::operation::put_inventory::PutInventoryError::ItemContentMismatchException(inner) => Error::ItemContentMismatchException(inner),
crate::operation::put_inventory::PutInventoryError::ItemSizeLimitExceededException(inner) => Error::ItemSizeLimitExceededException(inner),
crate::operation::put_inventory::PutInventoryError::SubTypeCountLimitExceededException(inner) => Error::SubTypeCountLimitExceededException(inner),
crate::operation::put_inventory::PutInventoryError::TotalSizeLimitExceededException(inner) => Error::TotalSizeLimitExceededException(inner),
crate::operation::put_inventory::PutInventoryError::UnsupportedInventoryItemContextException(inner) => Error::UnsupportedInventoryItemContextException(inner),
crate::operation::put_inventory::PutInventoryError::UnsupportedInventorySchemaVersionException(inner) => Error::UnsupportedInventorySchemaVersionException(inner),
crate::operation::put_inventory::PutInventoryError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<aws_smithy_http::result::SdkError<crate::operation::put_parameter::PutParameterError, R>>
for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::put_parameter::PutParameterError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::put_parameter::PutParameterError> for Error {
fn from(err: crate::operation::put_parameter::PutParameterError) -> Self {
match err {
crate::operation::put_parameter::PutParameterError::HierarchyLevelLimitExceededException(inner) => Error::HierarchyLevelLimitExceededException(inner),
crate::operation::put_parameter::PutParameterError::HierarchyTypeMismatchException(inner) => Error::HierarchyTypeMismatchException(inner),
crate::operation::put_parameter::PutParameterError::IncompatiblePolicyException(inner) => Error::IncompatiblePolicyException(inner),
crate::operation::put_parameter::PutParameterError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::put_parameter::PutParameterError::InvalidAllowedPatternException(inner) => Error::InvalidAllowedPatternException(inner),
crate::operation::put_parameter::PutParameterError::InvalidKeyId(inner) => Error::InvalidKeyId(inner),
crate::operation::put_parameter::PutParameterError::InvalidPolicyAttributeException(inner) => Error::InvalidPolicyAttributeException(inner),
crate::operation::put_parameter::PutParameterError::InvalidPolicyTypeException(inner) => Error::InvalidPolicyTypeException(inner),
crate::operation::put_parameter::PutParameterError::ParameterAlreadyExists(inner) => Error::ParameterAlreadyExists(inner),
crate::operation::put_parameter::PutParameterError::ParameterLimitExceeded(inner) => Error::ParameterLimitExceeded(inner),
crate::operation::put_parameter::PutParameterError::ParameterMaxVersionLimitExceeded(inner) => Error::ParameterMaxVersionLimitExceeded(inner),
crate::operation::put_parameter::PutParameterError::ParameterPatternMismatchException(inner) => Error::ParameterPatternMismatchException(inner),
crate::operation::put_parameter::PutParameterError::PoliciesLimitExceededException(inner) => Error::PoliciesLimitExceededException(inner),
crate::operation::put_parameter::PutParameterError::TooManyUpdates(inner) => Error::TooManyUpdates(inner),
crate::operation::put_parameter::PutParameterError::UnsupportedParameterType(inner) => Error::UnsupportedParameterType(inner),
crate::operation::put_parameter::PutParameterError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::put_resource_policy::PutResourcePolicyError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::put_resource_policy::PutResourcePolicyError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::put_resource_policy::PutResourcePolicyError> for Error {
fn from(err: crate::operation::put_resource_policy::PutResourcePolicyError) -> Self {
match err {
crate::operation::put_resource_policy::PutResourcePolicyError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::put_resource_policy::PutResourcePolicyError::ResourcePolicyConflictException(inner) => Error::ResourcePolicyConflictException(inner),
crate::operation::put_resource_policy::PutResourcePolicyError::ResourcePolicyInvalidParameterException(inner) => Error::ResourcePolicyInvalidParameterException(inner),
crate::operation::put_resource_policy::PutResourcePolicyError::ResourcePolicyLimitExceededException(inner) => Error::ResourcePolicyLimitExceededException(inner),
crate::operation::put_resource_policy::PutResourcePolicyError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::register_default_patch_baseline::RegisterDefaultPatchBaselineError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::register_default_patch_baseline::RegisterDefaultPatchBaselineError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::register_default_patch_baseline::RegisterDefaultPatchBaselineError>
for Error
{
fn from(
err: crate::operation::register_default_patch_baseline::RegisterDefaultPatchBaselineError,
) -> Self {
match err {
crate::operation::register_default_patch_baseline::RegisterDefaultPatchBaselineError::DoesNotExistException(inner) => Error::DoesNotExistException(inner),
crate::operation::register_default_patch_baseline::RegisterDefaultPatchBaselineError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::register_default_patch_baseline::RegisterDefaultPatchBaselineError::InvalidResourceId(inner) => Error::InvalidResourceId(inner),
crate::operation::register_default_patch_baseline::RegisterDefaultPatchBaselineError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::register_patch_baseline_for_patch_group::RegisterPatchBaselineForPatchGroupError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
fn from(err: aws_smithy_http::result::SdkError<crate::operation::register_patch_baseline_for_patch_group::RegisterPatchBaselineForPatchGroupError, R>) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
.source(err)
.build()
),
}
}
}
impl From<crate::operation::register_patch_baseline_for_patch_group::RegisterPatchBaselineForPatchGroupError> for Error {
fn from(err: crate::operation::register_patch_baseline_for_patch_group::RegisterPatchBaselineForPatchGroupError) -> Self {
match err {
crate::operation::register_patch_baseline_for_patch_group::RegisterPatchBaselineForPatchGroupError::AlreadyExistsException(inner) => Error::AlreadyExistsException(inner),
crate::operation::register_patch_baseline_for_patch_group::RegisterPatchBaselineForPatchGroupError::DoesNotExistException(inner) => Error::DoesNotExistException(inner),
crate::operation::register_patch_baseline_for_patch_group::RegisterPatchBaselineForPatchGroupError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::register_patch_baseline_for_patch_group::RegisterPatchBaselineForPatchGroupError::InvalidResourceId(inner) => Error::InvalidResourceId(inner),
crate::operation::register_patch_baseline_for_patch_group::RegisterPatchBaselineForPatchGroupError::ResourceLimitExceededException(inner) => Error::ResourceLimitExceededException(inner),
crate::operation::register_patch_baseline_for_patch_group::RegisterPatchBaselineForPatchGroupError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::register_target_with_maintenance_window::RegisterTargetWithMaintenanceWindowError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
fn from(err: aws_smithy_http::result::SdkError<crate::operation::register_target_with_maintenance_window::RegisterTargetWithMaintenanceWindowError, R>) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
.source(err)
.build()
),
}
}
}
impl From<crate::operation::register_target_with_maintenance_window::RegisterTargetWithMaintenanceWindowError> for Error {
fn from(err: crate::operation::register_target_with_maintenance_window::RegisterTargetWithMaintenanceWindowError) -> Self {
match err {
crate::operation::register_target_with_maintenance_window::RegisterTargetWithMaintenanceWindowError::DoesNotExistException(inner) => Error::DoesNotExistException(inner),
crate::operation::register_target_with_maintenance_window::RegisterTargetWithMaintenanceWindowError::IdempotentParameterMismatch(inner) => Error::IdempotentParameterMismatch(inner),
crate::operation::register_target_with_maintenance_window::RegisterTargetWithMaintenanceWindowError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::register_target_with_maintenance_window::RegisterTargetWithMaintenanceWindowError::ResourceLimitExceededException(inner) => Error::ResourceLimitExceededException(inner),
crate::operation::register_target_with_maintenance_window::RegisterTargetWithMaintenanceWindowError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindowError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
fn from(err: aws_smithy_http::result::SdkError<crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindowError, R>) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
.source(err)
.build()
),
}
}
}
impl From<crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindowError> for Error {
fn from(err: crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindowError) -> Self {
match err {
crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindowError::DoesNotExistException(inner) => Error::DoesNotExistException(inner),
crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindowError::FeatureNotAvailableException(inner) => Error::FeatureNotAvailableException(inner),
crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindowError::IdempotentParameterMismatch(inner) => Error::IdempotentParameterMismatch(inner),
crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindowError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindowError::ResourceLimitExceededException(inner) => Error::ResourceLimitExceededException(inner),
crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindowError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::remove_tags_from_resource::RemoveTagsFromResourceError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::remove_tags_from_resource::RemoveTagsFromResourceError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::remove_tags_from_resource::RemoveTagsFromResourceError> for Error {
fn from(err: crate::operation::remove_tags_from_resource::RemoveTagsFromResourceError) -> Self {
match err {
crate::operation::remove_tags_from_resource::RemoveTagsFromResourceError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::remove_tags_from_resource::RemoveTagsFromResourceError::InvalidResourceId(inner) => Error::InvalidResourceId(inner),
crate::operation::remove_tags_from_resource::RemoveTagsFromResourceError::InvalidResourceType(inner) => Error::InvalidResourceType(inner),
crate::operation::remove_tags_from_resource::RemoveTagsFromResourceError::TooManyUpdates(inner) => Error::TooManyUpdates(inner),
crate::operation::remove_tags_from_resource::RemoveTagsFromResourceError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::reset_service_setting::ResetServiceSettingError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::reset_service_setting::ResetServiceSettingError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::reset_service_setting::ResetServiceSettingError> for Error {
fn from(err: crate::operation::reset_service_setting::ResetServiceSettingError) -> Self {
match err {
crate::operation::reset_service_setting::ResetServiceSettingError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::reset_service_setting::ResetServiceSettingError::ServiceSettingNotFound(inner) => Error::ServiceSettingNotFound(inner),
crate::operation::reset_service_setting::ResetServiceSettingError::TooManyUpdates(inner) => Error::TooManyUpdates(inner),
crate::operation::reset_service_setting::ResetServiceSettingError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<aws_smithy_http::result::SdkError<crate::operation::resume_session::ResumeSessionError, R>>
for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::resume_session::ResumeSessionError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::resume_session::ResumeSessionError> for Error {
fn from(err: crate::operation::resume_session::ResumeSessionError) -> Self {
match err {
crate::operation::resume_session::ResumeSessionError::DoesNotExistException(inner) => {
Error::DoesNotExistException(inner)
}
crate::operation::resume_session::ResumeSessionError::InternalServerError(inner) => {
Error::InternalServerError(inner)
}
crate::operation::resume_session::ResumeSessionError::Unhandled(inner) => {
Error::Unhandled(inner)
}
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::send_automation_signal::SendAutomationSignalError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::send_automation_signal::SendAutomationSignalError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::send_automation_signal::SendAutomationSignalError> for Error {
fn from(err: crate::operation::send_automation_signal::SendAutomationSignalError) -> Self {
match err {
crate::operation::send_automation_signal::SendAutomationSignalError::AutomationExecutionNotFoundException(inner) => Error::AutomationExecutionNotFoundException(inner),
crate::operation::send_automation_signal::SendAutomationSignalError::AutomationStepNotFoundException(inner) => Error::AutomationStepNotFoundException(inner),
crate::operation::send_automation_signal::SendAutomationSignalError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::send_automation_signal::SendAutomationSignalError::InvalidAutomationSignalException(inner) => Error::InvalidAutomationSignalException(inner),
crate::operation::send_automation_signal::SendAutomationSignalError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::send_command::SendCommandError, R>>
for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<crate::operation::send_command::SendCommandError, R>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::send_command::SendCommandError> for Error {
fn from(err: crate::operation::send_command::SendCommandError) -> Self {
match err {
crate::operation::send_command::SendCommandError::DuplicateInstanceId(inner) => {
Error::DuplicateInstanceId(inner)
}
crate::operation::send_command::SendCommandError::InternalServerError(inner) => {
Error::InternalServerError(inner)
}
crate::operation::send_command::SendCommandError::InvalidDocument(inner) => {
Error::InvalidDocument(inner)
}
crate::operation::send_command::SendCommandError::InvalidDocumentVersion(inner) => {
Error::InvalidDocumentVersion(inner)
}
crate::operation::send_command::SendCommandError::InvalidInstanceId(inner) => {
Error::InvalidInstanceId(inner)
}
crate::operation::send_command::SendCommandError::InvalidNotificationConfig(inner) => {
Error::InvalidNotificationConfig(inner)
}
crate::operation::send_command::SendCommandError::InvalidOutputFolder(inner) => {
Error::InvalidOutputFolder(inner)
}
crate::operation::send_command::SendCommandError::InvalidParameters(inner) => {
Error::InvalidParameters(inner)
}
crate::operation::send_command::SendCommandError::InvalidRole(inner) => {
Error::InvalidRole(inner)
}
crate::operation::send_command::SendCommandError::MaxDocumentSizeExceeded(inner) => {
Error::MaxDocumentSizeExceeded(inner)
}
crate::operation::send_command::SendCommandError::UnsupportedPlatformType(inner) => {
Error::UnsupportedPlatformType(inner)
}
crate::operation::send_command::SendCommandError::Unhandled(inner) => {
Error::Unhandled(inner)
}
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::start_associations_once::StartAssociationsOnceError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::start_associations_once::StartAssociationsOnceError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::start_associations_once::StartAssociationsOnceError> for Error {
fn from(err: crate::operation::start_associations_once::StartAssociationsOnceError) -> Self {
match err {
crate::operation::start_associations_once::StartAssociationsOnceError::AssociationDoesNotExist(inner) => Error::AssociationDoesNotExist(inner),
crate::operation::start_associations_once::StartAssociationsOnceError::InvalidAssociation(inner) => Error::InvalidAssociation(inner),
crate::operation::start_associations_once::StartAssociationsOnceError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::start_automation_execution::StartAutomationExecutionError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::start_automation_execution::StartAutomationExecutionError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::start_automation_execution::StartAutomationExecutionError> for Error {
fn from(
err: crate::operation::start_automation_execution::StartAutomationExecutionError,
) -> Self {
match err {
crate::operation::start_automation_execution::StartAutomationExecutionError::AutomationDefinitionNotFoundException(inner) => Error::AutomationDefinitionNotFoundException(inner),
crate::operation::start_automation_execution::StartAutomationExecutionError::AutomationDefinitionVersionNotFoundException(inner) => Error::AutomationDefinitionVersionNotFoundException(inner),
crate::operation::start_automation_execution::StartAutomationExecutionError::AutomationExecutionLimitExceededException(inner) => Error::AutomationExecutionLimitExceededException(inner),
crate::operation::start_automation_execution::StartAutomationExecutionError::IdempotentParameterMismatch(inner) => Error::IdempotentParameterMismatch(inner),
crate::operation::start_automation_execution::StartAutomationExecutionError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::start_automation_execution::StartAutomationExecutionError::InvalidAutomationExecutionParametersException(inner) => Error::InvalidAutomationExecutionParametersException(inner),
crate::operation::start_automation_execution::StartAutomationExecutionError::InvalidTarget(inner) => Error::InvalidTarget(inner),
crate::operation::start_automation_execution::StartAutomationExecutionError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::start_change_request_execution::StartChangeRequestExecutionError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::start_change_request_execution::StartChangeRequestExecutionError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::start_change_request_execution::StartChangeRequestExecutionError>
for Error
{
fn from(
err: crate::operation::start_change_request_execution::StartChangeRequestExecutionError,
) -> Self {
match err {
crate::operation::start_change_request_execution::StartChangeRequestExecutionError::AutomationDefinitionNotApprovedException(inner) => Error::AutomationDefinitionNotApprovedException(inner),
crate::operation::start_change_request_execution::StartChangeRequestExecutionError::AutomationDefinitionNotFoundException(inner) => Error::AutomationDefinitionNotFoundException(inner),
crate::operation::start_change_request_execution::StartChangeRequestExecutionError::AutomationDefinitionVersionNotFoundException(inner) => Error::AutomationDefinitionVersionNotFoundException(inner),
crate::operation::start_change_request_execution::StartChangeRequestExecutionError::AutomationExecutionLimitExceededException(inner) => Error::AutomationExecutionLimitExceededException(inner),
crate::operation::start_change_request_execution::StartChangeRequestExecutionError::IdempotentParameterMismatch(inner) => Error::IdempotentParameterMismatch(inner),
crate::operation::start_change_request_execution::StartChangeRequestExecutionError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::start_change_request_execution::StartChangeRequestExecutionError::InvalidAutomationExecutionParametersException(inner) => Error::InvalidAutomationExecutionParametersException(inner),
crate::operation::start_change_request_execution::StartChangeRequestExecutionError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<aws_smithy_http::result::SdkError<crate::operation::start_session::StartSessionError, R>>
for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::start_session::StartSessionError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::start_session::StartSessionError> for Error {
fn from(err: crate::operation::start_session::StartSessionError) -> Self {
match err {
crate::operation::start_session::StartSessionError::InternalServerError(inner) => {
Error::InternalServerError(inner)
}
crate::operation::start_session::StartSessionError::InvalidDocument(inner) => {
Error::InvalidDocument(inner)
}
crate::operation::start_session::StartSessionError::TargetNotConnected(inner) => {
Error::TargetNotConnected(inner)
}
crate::operation::start_session::StartSessionError::Unhandled(inner) => {
Error::Unhandled(inner)
}
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::stop_automation_execution::StopAutomationExecutionError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::stop_automation_execution::StopAutomationExecutionError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::stop_automation_execution::StopAutomationExecutionError> for Error {
fn from(
err: crate::operation::stop_automation_execution::StopAutomationExecutionError,
) -> Self {
match err {
crate::operation::stop_automation_execution::StopAutomationExecutionError::AutomationExecutionNotFoundException(inner) => Error::AutomationExecutionNotFoundException(inner),
crate::operation::stop_automation_execution::StopAutomationExecutionError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::stop_automation_execution::StopAutomationExecutionError::InvalidAutomationStatusUpdateException(inner) => Error::InvalidAutomationStatusUpdateException(inner),
crate::operation::stop_automation_execution::StopAutomationExecutionError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::terminate_session::TerminateSessionError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::terminate_session::TerminateSessionError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::terminate_session::TerminateSessionError> for Error {
fn from(err: crate::operation::terminate_session::TerminateSessionError) -> Self {
match err {
crate::operation::terminate_session::TerminateSessionError::InternalServerError(
inner,
) => Error::InternalServerError(inner),
crate::operation::terminate_session::TerminateSessionError::Unhandled(inner) => {
Error::Unhandled(inner)
}
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::unlabel_parameter_version::UnlabelParameterVersionError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::unlabel_parameter_version::UnlabelParameterVersionError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::unlabel_parameter_version::UnlabelParameterVersionError> for Error {
fn from(
err: crate::operation::unlabel_parameter_version::UnlabelParameterVersionError,
) -> Self {
match err {
crate::operation::unlabel_parameter_version::UnlabelParameterVersionError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::unlabel_parameter_version::UnlabelParameterVersionError::ParameterNotFound(inner) => Error::ParameterNotFound(inner),
crate::operation::unlabel_parameter_version::UnlabelParameterVersionError::ParameterVersionNotFound(inner) => Error::ParameterVersionNotFound(inner),
crate::operation::unlabel_parameter_version::UnlabelParameterVersionError::TooManyUpdates(inner) => Error::TooManyUpdates(inner),
crate::operation::unlabel_parameter_version::UnlabelParameterVersionError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::update_association::UpdateAssociationError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::update_association::UpdateAssociationError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::update_association::UpdateAssociationError> for Error {
fn from(err: crate::operation::update_association::UpdateAssociationError) -> Self {
match err {
crate::operation::update_association::UpdateAssociationError::AssociationDoesNotExist(inner) => Error::AssociationDoesNotExist(inner),
crate::operation::update_association::UpdateAssociationError::AssociationVersionLimitExceeded(inner) => Error::AssociationVersionLimitExceeded(inner),
crate::operation::update_association::UpdateAssociationError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::update_association::UpdateAssociationError::InvalidAssociationVersion(inner) => Error::InvalidAssociationVersion(inner),
crate::operation::update_association::UpdateAssociationError::InvalidDocument(inner) => Error::InvalidDocument(inner),
crate::operation::update_association::UpdateAssociationError::InvalidDocumentVersion(inner) => Error::InvalidDocumentVersion(inner),
crate::operation::update_association::UpdateAssociationError::InvalidOutputLocation(inner) => Error::InvalidOutputLocation(inner),
crate::operation::update_association::UpdateAssociationError::InvalidParameters(inner) => Error::InvalidParameters(inner),
crate::operation::update_association::UpdateAssociationError::InvalidSchedule(inner) => Error::InvalidSchedule(inner),
crate::operation::update_association::UpdateAssociationError::InvalidTarget(inner) => Error::InvalidTarget(inner),
crate::operation::update_association::UpdateAssociationError::InvalidTargetMaps(inner) => Error::InvalidTargetMaps(inner),
crate::operation::update_association::UpdateAssociationError::InvalidUpdate(inner) => Error::InvalidUpdate(inner),
crate::operation::update_association::UpdateAssociationError::TooManyUpdates(inner) => Error::TooManyUpdates(inner),
crate::operation::update_association::UpdateAssociationError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::update_association_status::UpdateAssociationStatusError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::update_association_status::UpdateAssociationStatusError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::update_association_status::UpdateAssociationStatusError> for Error {
fn from(
err: crate::operation::update_association_status::UpdateAssociationStatusError,
) -> Self {
match err {
crate::operation::update_association_status::UpdateAssociationStatusError::AssociationDoesNotExist(inner) => Error::AssociationDoesNotExist(inner),
crate::operation::update_association_status::UpdateAssociationStatusError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::update_association_status::UpdateAssociationStatusError::InvalidDocument(inner) => Error::InvalidDocument(inner),
crate::operation::update_association_status::UpdateAssociationStatusError::InvalidInstanceId(inner) => Error::InvalidInstanceId(inner),
crate::operation::update_association_status::UpdateAssociationStatusError::StatusUnchanged(inner) => Error::StatusUnchanged(inner),
crate::operation::update_association_status::UpdateAssociationStatusError::TooManyUpdates(inner) => Error::TooManyUpdates(inner),
crate::operation::update_association_status::UpdateAssociationStatusError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::update_document::UpdateDocumentError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::update_document::UpdateDocumentError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::update_document::UpdateDocumentError> for Error {
fn from(err: crate::operation::update_document::UpdateDocumentError) -> Self {
match err {
crate::operation::update_document::UpdateDocumentError::DocumentVersionLimitExceeded(inner) => Error::DocumentVersionLimitExceeded(inner),
crate::operation::update_document::UpdateDocumentError::DuplicateDocumentContent(inner) => Error::DuplicateDocumentContent(inner),
crate::operation::update_document::UpdateDocumentError::DuplicateDocumentVersionName(inner) => Error::DuplicateDocumentVersionName(inner),
crate::operation::update_document::UpdateDocumentError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::update_document::UpdateDocumentError::InvalidDocument(inner) => Error::InvalidDocument(inner),
crate::operation::update_document::UpdateDocumentError::InvalidDocumentContent(inner) => Error::InvalidDocumentContent(inner),
crate::operation::update_document::UpdateDocumentError::InvalidDocumentOperation(inner) => Error::InvalidDocumentOperation(inner),
crate::operation::update_document::UpdateDocumentError::InvalidDocumentSchemaVersion(inner) => Error::InvalidDocumentSchemaVersion(inner),
crate::operation::update_document::UpdateDocumentError::InvalidDocumentVersion(inner) => Error::InvalidDocumentVersion(inner),
crate::operation::update_document::UpdateDocumentError::MaxDocumentSizeExceeded(inner) => Error::MaxDocumentSizeExceeded(inner),
crate::operation::update_document::UpdateDocumentError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::update_document_default_version::UpdateDocumentDefaultVersionError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::update_document_default_version::UpdateDocumentDefaultVersionError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::update_document_default_version::UpdateDocumentDefaultVersionError>
for Error
{
fn from(
err: crate::operation::update_document_default_version::UpdateDocumentDefaultVersionError,
) -> Self {
match err {
crate::operation::update_document_default_version::UpdateDocumentDefaultVersionError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::update_document_default_version::UpdateDocumentDefaultVersionError::InvalidDocument(inner) => Error::InvalidDocument(inner),
crate::operation::update_document_default_version::UpdateDocumentDefaultVersionError::InvalidDocumentSchemaVersion(inner) => Error::InvalidDocumentSchemaVersion(inner),
crate::operation::update_document_default_version::UpdateDocumentDefaultVersionError::InvalidDocumentVersion(inner) => Error::InvalidDocumentVersion(inner),
crate::operation::update_document_default_version::UpdateDocumentDefaultVersionError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::update_document_metadata::UpdateDocumentMetadataError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::update_document_metadata::UpdateDocumentMetadataError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::update_document_metadata::UpdateDocumentMetadataError> for Error {
fn from(err: crate::operation::update_document_metadata::UpdateDocumentMetadataError) -> Self {
match err {
crate::operation::update_document_metadata::UpdateDocumentMetadataError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::update_document_metadata::UpdateDocumentMetadataError::InvalidDocument(inner) => Error::InvalidDocument(inner),
crate::operation::update_document_metadata::UpdateDocumentMetadataError::InvalidDocumentOperation(inner) => Error::InvalidDocumentOperation(inner),
crate::operation::update_document_metadata::UpdateDocumentMetadataError::InvalidDocumentVersion(inner) => Error::InvalidDocumentVersion(inner),
crate::operation::update_document_metadata::UpdateDocumentMetadataError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::update_maintenance_window::UpdateMaintenanceWindowError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::update_maintenance_window::UpdateMaintenanceWindowError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::update_maintenance_window::UpdateMaintenanceWindowError> for Error {
fn from(
err: crate::operation::update_maintenance_window::UpdateMaintenanceWindowError,
) -> Self {
match err {
crate::operation::update_maintenance_window::UpdateMaintenanceWindowError::DoesNotExistException(inner) => Error::DoesNotExistException(inner),
crate::operation::update_maintenance_window::UpdateMaintenanceWindowError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::update_maintenance_window::UpdateMaintenanceWindowError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::update_maintenance_window_target::UpdateMaintenanceWindowTargetError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::update_maintenance_window_target::UpdateMaintenanceWindowTargetError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::update_maintenance_window_target::UpdateMaintenanceWindowTargetError>
for Error
{
fn from(
err: crate::operation::update_maintenance_window_target::UpdateMaintenanceWindowTargetError,
) -> Self {
match err {
crate::operation::update_maintenance_window_target::UpdateMaintenanceWindowTargetError::DoesNotExistException(inner) => Error::DoesNotExistException(inner),
crate::operation::update_maintenance_window_target::UpdateMaintenanceWindowTargetError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::update_maintenance_window_target::UpdateMaintenanceWindowTargetError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::update_maintenance_window_task::UpdateMaintenanceWindowTaskError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::update_maintenance_window_task::UpdateMaintenanceWindowTaskError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::update_maintenance_window_task::UpdateMaintenanceWindowTaskError>
for Error
{
fn from(
err: crate::operation::update_maintenance_window_task::UpdateMaintenanceWindowTaskError,
) -> Self {
match err {
crate::operation::update_maintenance_window_task::UpdateMaintenanceWindowTaskError::DoesNotExistException(inner) => Error::DoesNotExistException(inner),
crate::operation::update_maintenance_window_task::UpdateMaintenanceWindowTaskError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::update_maintenance_window_task::UpdateMaintenanceWindowTaskError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::update_managed_instance_role::UpdateManagedInstanceRoleError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::update_managed_instance_role::UpdateManagedInstanceRoleError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::update_managed_instance_role::UpdateManagedInstanceRoleError>
for Error
{
fn from(
err: crate::operation::update_managed_instance_role::UpdateManagedInstanceRoleError,
) -> Self {
match err {
crate::operation::update_managed_instance_role::UpdateManagedInstanceRoleError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::update_managed_instance_role::UpdateManagedInstanceRoleError::InvalidInstanceId(inner) => Error::InvalidInstanceId(inner),
crate::operation::update_managed_instance_role::UpdateManagedInstanceRoleError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<crate::operation::update_ops_item::UpdateOpsItemError, R>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::update_ops_item::UpdateOpsItemError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::update_ops_item::UpdateOpsItemError> for Error {
fn from(err: crate::operation::update_ops_item::UpdateOpsItemError) -> Self {
match err {
crate::operation::update_ops_item::UpdateOpsItemError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::update_ops_item::UpdateOpsItemError::OpsItemAccessDeniedException(inner) => Error::OpsItemAccessDeniedException(inner),
crate::operation::update_ops_item::UpdateOpsItemError::OpsItemAlreadyExistsException(inner) => Error::OpsItemAlreadyExistsException(inner),
crate::operation::update_ops_item::UpdateOpsItemError::OpsItemInvalidParameterException(inner) => Error::OpsItemInvalidParameterException(inner),
crate::operation::update_ops_item::UpdateOpsItemError::OpsItemLimitExceededException(inner) => Error::OpsItemLimitExceededException(inner),
crate::operation::update_ops_item::UpdateOpsItemError::OpsItemNotFoundException(inner) => Error::OpsItemNotFoundException(inner),
crate::operation::update_ops_item::UpdateOpsItemError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::update_ops_metadata::UpdateOpsMetadataError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::update_ops_metadata::UpdateOpsMetadataError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::update_ops_metadata::UpdateOpsMetadataError> for Error {
fn from(err: crate::operation::update_ops_metadata::UpdateOpsMetadataError) -> Self {
match err {
crate::operation::update_ops_metadata::UpdateOpsMetadataError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::update_ops_metadata::UpdateOpsMetadataError::OpsMetadataInvalidArgumentException(inner) => Error::OpsMetadataInvalidArgumentException(inner),
crate::operation::update_ops_metadata::UpdateOpsMetadataError::OpsMetadataKeyLimitExceededException(inner) => Error::OpsMetadataKeyLimitExceededException(inner),
crate::operation::update_ops_metadata::UpdateOpsMetadataError::OpsMetadataNotFoundException(inner) => Error::OpsMetadataNotFoundException(inner),
crate::operation::update_ops_metadata::UpdateOpsMetadataError::OpsMetadataTooManyUpdatesException(inner) => Error::OpsMetadataTooManyUpdatesException(inner),
crate::operation::update_ops_metadata::UpdateOpsMetadataError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::update_patch_baseline::UpdatePatchBaselineError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::update_patch_baseline::UpdatePatchBaselineError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::update_patch_baseline::UpdatePatchBaselineError> for Error {
fn from(err: crate::operation::update_patch_baseline::UpdatePatchBaselineError) -> Self {
match err {
crate::operation::update_patch_baseline::UpdatePatchBaselineError::DoesNotExistException(inner) => Error::DoesNotExistException(inner),
crate::operation::update_patch_baseline::UpdatePatchBaselineError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::update_patch_baseline::UpdatePatchBaselineError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::update_resource_data_sync::UpdateResourceDataSyncError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::update_resource_data_sync::UpdateResourceDataSyncError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::update_resource_data_sync::UpdateResourceDataSyncError> for Error {
fn from(err: crate::operation::update_resource_data_sync::UpdateResourceDataSyncError) -> Self {
match err {
crate::operation::update_resource_data_sync::UpdateResourceDataSyncError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::update_resource_data_sync::UpdateResourceDataSyncError::ResourceDataSyncConflictException(inner) => Error::ResourceDataSyncConflictException(inner),
crate::operation::update_resource_data_sync::UpdateResourceDataSyncError::ResourceDataSyncInvalidConfigurationException(inner) => Error::ResourceDataSyncInvalidConfigurationException(inner),
crate::operation::update_resource_data_sync::UpdateResourceDataSyncError::ResourceDataSyncNotFoundException(inner) => Error::ResourceDataSyncNotFoundException(inner),
crate::operation::update_resource_data_sync::UpdateResourceDataSyncError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl<R>
From<
aws_smithy_http::result::SdkError<
crate::operation::update_service_setting::UpdateServiceSettingError,
R,
>,
> for Error
where
R: Send + Sync + std::fmt::Debug + 'static,
{
fn from(
err: aws_smithy_http::result::SdkError<
crate::operation::update_service_setting::UpdateServiceSettingError,
R,
>,
) -> Self {
match err {
aws_smithy_http::result::SdkError::ServiceError(context) => {
Self::from(context.into_err())
}
_ => Error::Unhandled(
aws_smithy_types::error::Unhandled::builder()
.meta(
aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
)
.source(err)
.build(),
),
}
}
}
impl From<crate::operation::update_service_setting::UpdateServiceSettingError> for Error {
fn from(err: crate::operation::update_service_setting::UpdateServiceSettingError) -> Self {
match err {
crate::operation::update_service_setting::UpdateServiceSettingError::InternalServerError(inner) => Error::InternalServerError(inner),
crate::operation::update_service_setting::UpdateServiceSettingError::ServiceSettingNotFound(inner) => Error::ServiceSettingNotFound(inner),
crate::operation::update_service_setting::UpdateServiceSettingError::TooManyUpdates(inner) => Error::TooManyUpdates(inner),
crate::operation::update_service_setting::UpdateServiceSettingError::Unhandled(inner) => Error::Unhandled(inner),
}
}
}
impl std::error::Error for Error {}
impl aws_http::request_id::RequestId for Error {
fn request_id(&self) -> Option<&str> {
match self {
Self::AlreadyExistsException(e) => e.request_id(),
Self::AssociatedInstances(e) => e.request_id(),
Self::AssociationAlreadyExists(e) => e.request_id(),
Self::AssociationDoesNotExist(e) => e.request_id(),
Self::AssociationExecutionDoesNotExist(e) => e.request_id(),
Self::AssociationLimitExceeded(e) => e.request_id(),
Self::AssociationVersionLimitExceeded(e) => e.request_id(),
Self::AutomationDefinitionNotApprovedException(e) => e.request_id(),
Self::AutomationDefinitionNotFoundException(e) => e.request_id(),
Self::AutomationDefinitionVersionNotFoundException(e) => e.request_id(),
Self::AutomationExecutionLimitExceededException(e) => e.request_id(),
Self::AutomationExecutionNotFoundException(e) => e.request_id(),
Self::AutomationStepNotFoundException(e) => e.request_id(),
Self::ComplianceTypeCountLimitExceededException(e) => e.request_id(),
Self::CustomSchemaCountLimitExceededException(e) => e.request_id(),
Self::DocumentAlreadyExists(e) => e.request_id(),
Self::DocumentLimitExceeded(e) => e.request_id(),
Self::DocumentPermissionLimit(e) => e.request_id(),
Self::DocumentVersionLimitExceeded(e) => e.request_id(),
Self::DoesNotExistException(e) => e.request_id(),
Self::DuplicateDocumentContent(e) => e.request_id(),
Self::DuplicateDocumentVersionName(e) => e.request_id(),
Self::DuplicateInstanceId(e) => e.request_id(),
Self::FeatureNotAvailableException(e) => e.request_id(),
Self::HierarchyLevelLimitExceededException(e) => e.request_id(),
Self::HierarchyTypeMismatchException(e) => e.request_id(),
Self::IdempotentParameterMismatch(e) => e.request_id(),
Self::IncompatiblePolicyException(e) => e.request_id(),
Self::InternalServerError(e) => e.request_id(),
Self::InvalidActivation(e) => e.request_id(),
Self::InvalidActivationId(e) => e.request_id(),
Self::InvalidAggregatorException(e) => e.request_id(),
Self::InvalidAllowedPatternException(e) => e.request_id(),
Self::InvalidAssociation(e) => e.request_id(),
Self::InvalidAssociationVersion(e) => e.request_id(),
Self::InvalidAutomationExecutionParametersException(e) => e.request_id(),
Self::InvalidAutomationSignalException(e) => e.request_id(),
Self::InvalidAutomationStatusUpdateException(e) => e.request_id(),
Self::InvalidCommandId(e) => e.request_id(),
Self::InvalidDeleteInventoryParametersException(e) => e.request_id(),
Self::InvalidDeletionIdException(e) => e.request_id(),
Self::InvalidDocument(e) => e.request_id(),
Self::InvalidDocumentContent(e) => e.request_id(),
Self::InvalidDocumentOperation(e) => e.request_id(),
Self::InvalidDocumentSchemaVersion(e) => e.request_id(),
Self::InvalidDocumentType(e) => e.request_id(),
Self::InvalidDocumentVersion(e) => e.request_id(),
Self::InvalidFilter(e) => e.request_id(),
Self::InvalidFilterKey(e) => e.request_id(),
Self::InvalidFilterOption(e) => e.request_id(),
Self::InvalidFilterValue(e) => e.request_id(),
Self::InvalidInstanceId(e) => e.request_id(),
Self::InvalidInstanceInformationFilterValue(e) => e.request_id(),
Self::InvalidInventoryGroupException(e) => e.request_id(),
Self::InvalidInventoryItemContextException(e) => e.request_id(),
Self::InvalidInventoryRequestException(e) => e.request_id(),
Self::InvalidItemContentException(e) => e.request_id(),
Self::InvalidKeyId(e) => e.request_id(),
Self::InvalidNextToken(e) => e.request_id(),
Self::InvalidNotificationConfig(e) => e.request_id(),
Self::InvalidOptionException(e) => e.request_id(),
Self::InvalidOutputFolder(e) => e.request_id(),
Self::InvalidOutputLocation(e) => e.request_id(),
Self::InvalidParameters(e) => e.request_id(),
Self::InvalidPermissionType(e) => e.request_id(),
Self::InvalidPluginName(e) => e.request_id(),
Self::InvalidPolicyAttributeException(e) => e.request_id(),
Self::InvalidPolicyTypeException(e) => e.request_id(),
Self::InvalidResourceId(e) => e.request_id(),
Self::InvalidResourceType(e) => e.request_id(),
Self::InvalidResultAttributeException(e) => e.request_id(),
Self::InvalidRole(e) => e.request_id(),
Self::InvalidSchedule(e) => e.request_id(),
Self::InvalidTag(e) => e.request_id(),
Self::InvalidTarget(e) => e.request_id(),
Self::InvalidTargetMaps(e) => e.request_id(),
Self::InvalidTypeNameException(e) => e.request_id(),
Self::InvalidUpdate(e) => e.request_id(),
Self::InvocationDoesNotExist(e) => e.request_id(),
Self::ItemContentMismatchException(e) => e.request_id(),
Self::ItemSizeLimitExceededException(e) => e.request_id(),
Self::MaxDocumentSizeExceeded(e) => e.request_id(),
Self::OpsItemAccessDeniedException(e) => e.request_id(),
Self::OpsItemAlreadyExistsException(e) => e.request_id(),
Self::OpsItemInvalidParameterException(e) => e.request_id(),
Self::OpsItemLimitExceededException(e) => e.request_id(),
Self::OpsItemNotFoundException(e) => e.request_id(),
Self::OpsItemRelatedItemAlreadyExistsException(e) => e.request_id(),
Self::OpsItemRelatedItemAssociationNotFoundException(e) => e.request_id(),
Self::OpsMetadataAlreadyExistsException(e) => e.request_id(),
Self::OpsMetadataInvalidArgumentException(e) => e.request_id(),
Self::OpsMetadataKeyLimitExceededException(e) => e.request_id(),
Self::OpsMetadataLimitExceededException(e) => e.request_id(),
Self::OpsMetadataNotFoundException(e) => e.request_id(),
Self::OpsMetadataTooManyUpdatesException(e) => e.request_id(),
Self::ParameterAlreadyExists(e) => e.request_id(),
Self::ParameterLimitExceeded(e) => e.request_id(),
Self::ParameterMaxVersionLimitExceeded(e) => e.request_id(),
Self::ParameterNotFound(e) => e.request_id(),
Self::ParameterPatternMismatchException(e) => e.request_id(),
Self::ParameterVersionLabelLimitExceeded(e) => e.request_id(),
Self::ParameterVersionNotFound(e) => e.request_id(),
Self::PoliciesLimitExceededException(e) => e.request_id(),
Self::ResourceDataSyncAlreadyExistsException(e) => e.request_id(),
Self::ResourceDataSyncConflictException(e) => e.request_id(),
Self::ResourceDataSyncCountExceededException(e) => e.request_id(),
Self::ResourceDataSyncInvalidConfigurationException(e) => e.request_id(),
Self::ResourceDataSyncNotFoundException(e) => e.request_id(),
Self::ResourceInUseException(e) => e.request_id(),
Self::ResourceLimitExceededException(e) => e.request_id(),
Self::ResourcePolicyConflictException(e) => e.request_id(),
Self::ResourcePolicyInvalidParameterException(e) => e.request_id(),
Self::ResourcePolicyLimitExceededException(e) => e.request_id(),
Self::ServiceSettingNotFound(e) => e.request_id(),
Self::StatusUnchanged(e) => e.request_id(),
Self::SubTypeCountLimitExceededException(e) => e.request_id(),
Self::TargetInUseException(e) => e.request_id(),
Self::TargetNotConnected(e) => e.request_id(),
Self::TooManyTagsError(e) => e.request_id(),
Self::TooManyUpdates(e) => e.request_id(),
Self::TotalSizeLimitExceededException(e) => e.request_id(),
Self::UnsupportedCalendarException(e) => e.request_id(),
Self::UnsupportedFeatureRequiredException(e) => e.request_id(),
Self::UnsupportedInventoryItemContextException(e) => e.request_id(),
Self::UnsupportedInventorySchemaVersionException(e) => e.request_id(),
Self::UnsupportedOperatingSystem(e) => e.request_id(),
Self::UnsupportedParameterType(e) => e.request_id(),
Self::UnsupportedPlatformType(e) => e.request_id(),
Self::Unhandled(e) => e.request_id(),
}
}
}