diff --git a/.changelog/bugfix-cbor-modeled-errors.json b/.changelog/bugfix-cbor-modeled-errors.json
new file mode 100644
index 00000000000..a5505258ae1
--- /dev/null
+++ b/.changelog/bugfix-cbor-modeled-errors.json
@@ -0,0 +1,6 @@
+{
+  "type": "bugfix",
+  "category": "aws-cpp-sdk-core",
+  "contributor": "sbiscigl",
+  "description": "Generate GetModeledError for rpcv2Cbor errors that have members beyond Message"
+}
diff --git a/generated/src/aws-cpp-sdk-application-insights/source/ApplicationInsightsErrors.cpp b/generated/src/aws-cpp-sdk-application-insights/source/ApplicationInsightsErrors.cpp
index 49c750f2283..eb88a8b01d2 100644
--- a/generated/src/aws-cpp-sdk-application-insights/source/ApplicationInsightsErrors.cpp
+++ b/generated/src/aws-cpp-sdk-application-insights/source/ApplicationInsightsErrors.cpp
@@ -4,15 +4,25 @@
  */
 
 #include <aws/application-insights/ApplicationInsightsErrors.h>
+#include <aws/application-insights/model/TooManyTagsException.h>
 #include <aws/core/client/AWSError.h>
 #include <aws/core/utils/HashingUtils.h>
+#include <aws/core/utils/cbor/CborValue.h>
 
 using namespace Aws::Client;
 using namespace Aws::Utils;
 using namespace Aws::ApplicationInsights;
+using namespace Aws::ApplicationInsights::Model;
 
 namespace Aws {
 namespace ApplicationInsights {
+template <>
+AWS_APPLICATIONINSIGHTS_API TooManyTagsException ApplicationInsightsError::GetModeledError() {
+  assert(this->GetErrorType() == ApplicationInsightsErrors::TOO_MANY_TAGS);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return TooManyTagsException(payload.GetDecoder());
+}
+
 namespace ApplicationInsightsErrorMapper {
 
 static const int INTERNAL_SERVER_HASH = HashingUtils::HashString("InternalServerException");
diff --git a/generated/src/aws-cpp-sdk-arc-region-switch/source/ARCRegionswitchErrors.cpp b/generated/src/aws-cpp-sdk-arc-region-switch/source/ARCRegionswitchErrors.cpp
index 8ab6774c4a6..d9e1cc512ca 100644
--- a/generated/src/aws-cpp-sdk-arc-region-switch/source/ARCRegionswitchErrors.cpp
+++ b/generated/src/aws-cpp-sdk-arc-region-switch/source/ARCRegionswitchErrors.cpp
@@ -4,15 +4,30 @@
  */
 
 #include <aws/arc-region-switch/ARCRegionswitchErrors.h>
+#include <aws/arc-region-switch/model/ConflictException.h>
+#include <aws/arc-region-switch/model/RetryableConflictException.h>
 #include <aws/core/client/AWSError.h>
 #include <aws/core/utils/HashingUtils.h>
 
 using namespace Aws::Client;
 using namespace Aws::Utils;
 using namespace Aws::ARCRegionswitch;
+using namespace Aws::ARCRegionswitch::Model;
 
 namespace Aws {
 namespace ARCRegionswitch {
+template <>
+AWS_ARCREGIONSWITCH_API ConflictException ARCRegionswitchError::GetModeledError() {
+  assert(this->GetErrorType() == ARCRegionswitchErrors::CONFLICT);
+  return ConflictException(this->GetJsonPayload().View());
+}
+
+template <>
+AWS_ARCREGIONSWITCH_API RetryableConflictException ARCRegionswitchError::GetModeledError() {
+  assert(this->GetErrorType() == ARCRegionswitchErrors::RETRYABLE_CONFLICT);
+  return RetryableConflictException(this->GetJsonPayload().View());
+}
+
 namespace ARCRegionswitchErrorMapper {
 
 static const int CONFLICT_HASH = HashingUtils::HashString("ConflictException");
diff --git a/generated/src/aws-cpp-sdk-backup-gateway/source/BackupGatewayErrors.cpp b/generated/src/aws-cpp-sdk-backup-gateway/source/BackupGatewayErrors.cpp
index 426a6d81bea..c979b80b6e1 100644
--- a/generated/src/aws-cpp-sdk-backup-gateway/source/BackupGatewayErrors.cpp
+++ b/generated/src/aws-cpp-sdk-backup-gateway/source/BackupGatewayErrors.cpp
@@ -4,15 +4,65 @@
  */
 
 #include <aws/backup-gateway/BackupGatewayErrors.h>
+#include <aws/backup-gateway/model/AccessDeniedException.h>
+#include <aws/backup-gateway/model/ConflictException.h>
+#include <aws/backup-gateway/model/InternalServerException.h>
+#include <aws/backup-gateway/model/ResourceNotFoundException.h>
+#include <aws/backup-gateway/model/ThrottlingException.h>
+#include <aws/backup-gateway/model/ValidationException.h>
 #include <aws/core/client/AWSError.h>
 #include <aws/core/utils/HashingUtils.h>
+#include <aws/core/utils/cbor/CborValue.h>
 
 using namespace Aws::Client;
 using namespace Aws::Utils;
 using namespace Aws::BackupGateway;
+using namespace Aws::BackupGateway::Model;
 
 namespace Aws {
 namespace BackupGateway {
+template <>
+AWS_BACKUPGATEWAY_API ConflictException BackupGatewayError::GetModeledError() {
+  assert(this->GetErrorType() == BackupGatewayErrors::CONFLICT);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ConflictException(payload.GetDecoder());
+}
+
+template <>
+AWS_BACKUPGATEWAY_API ThrottlingException BackupGatewayError::GetModeledError() {
+  assert(this->GetErrorType() == BackupGatewayErrors::THROTTLING);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ThrottlingException(payload.GetDecoder());
+}
+
+template <>
+AWS_BACKUPGATEWAY_API InternalServerException BackupGatewayError::GetModeledError() {
+  assert(this->GetErrorType() == BackupGatewayErrors::INTERNAL_SERVER);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return InternalServerException(payload.GetDecoder());
+}
+
+template <>
+AWS_BACKUPGATEWAY_API ResourceNotFoundException BackupGatewayError::GetModeledError() {
+  assert(this->GetErrorType() == BackupGatewayErrors::RESOURCE_NOT_FOUND);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ResourceNotFoundException(payload.GetDecoder());
+}
+
+template <>
+AWS_BACKUPGATEWAY_API ValidationException BackupGatewayError::GetModeledError() {
+  assert(this->GetErrorType() == BackupGatewayErrors::VALIDATION);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ValidationException(payload.GetDecoder());
+}
+
+template <>
+AWS_BACKUPGATEWAY_API AccessDeniedException BackupGatewayError::GetModeledError() {
+  assert(this->GetErrorType() == BackupGatewayErrors::ACCESS_DENIED);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return AccessDeniedException(payload.GetDecoder());
+}
+
 namespace BackupGatewayErrorMapper {
 
 static const int CONFLICT_HASH = HashingUtils::HashString("ConflictException");
diff --git a/generated/src/aws-cpp-sdk-cloudwatchomni/source/CloudWatchOmniErrors.cpp b/generated/src/aws-cpp-sdk-cloudwatchomni/source/CloudWatchOmniErrors.cpp
index e9474338a87..a1f97f50ba6 100644
--- a/generated/src/aws-cpp-sdk-cloudwatchomni/source/CloudWatchOmniErrors.cpp
+++ b/generated/src/aws-cpp-sdk-cloudwatchomni/source/CloudWatchOmniErrors.cpp
@@ -4,15 +4,57 @@
  */
 
 #include <aws/cloudwatchomni/CloudWatchOmniErrors.h>
+#include <aws/cloudwatchomni/model/ConflictException.h>
+#include <aws/cloudwatchomni/model/InternalServerException.h>
+#include <aws/cloudwatchomni/model/ResourceNotFoundException.h>
+#include <aws/cloudwatchomni/model/ThrottlingException.h>
+#include <aws/cloudwatchomni/model/ValidationException.h>
 #include <aws/core/client/AWSError.h>
 #include <aws/core/utils/HashingUtils.h>
+#include <aws/core/utils/cbor/CborValue.h>
 
 using namespace Aws::Client;
 using namespace Aws::Utils;
 using namespace Aws::CloudWatchOmni;
+using namespace Aws::CloudWatchOmni::Model;
 
 namespace Aws {
 namespace CloudWatchOmni {
+template <>
+AWS_CLOUDWATCHOMNI_API ConflictException CloudWatchOmniError::GetModeledError() {
+  assert(this->GetErrorType() == CloudWatchOmniErrors::CONFLICT);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ConflictException(payload.GetDecoder());
+}
+
+template <>
+AWS_CLOUDWATCHOMNI_API ThrottlingException CloudWatchOmniError::GetModeledError() {
+  assert(this->GetErrorType() == CloudWatchOmniErrors::THROTTLING);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ThrottlingException(payload.GetDecoder());
+}
+
+template <>
+AWS_CLOUDWATCHOMNI_API ResourceNotFoundException CloudWatchOmniError::GetModeledError() {
+  assert(this->GetErrorType() == CloudWatchOmniErrors::RESOURCE_NOT_FOUND);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ResourceNotFoundException(payload.GetDecoder());
+}
+
+template <>
+AWS_CLOUDWATCHOMNI_API InternalServerException CloudWatchOmniError::GetModeledError() {
+  assert(this->GetErrorType() == CloudWatchOmniErrors::INTERNAL_SERVER);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return InternalServerException(payload.GetDecoder());
+}
+
+template <>
+AWS_CLOUDWATCHOMNI_API ValidationException CloudWatchOmniError::GetModeledError() {
+  assert(this->GetErrorType() == CloudWatchOmniErrors::VALIDATION);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ValidationException(payload.GetDecoder());
+}
+
 namespace CloudWatchOmniErrorMapper {
 
 static const int CONFLICT_HASH = HashingUtils::HashString("ConflictException");
diff --git a/generated/src/aws-cpp-sdk-comprehend/source/ComprehendErrors.cpp b/generated/src/aws-cpp-sdk-comprehend/source/ComprehendErrors.cpp
index a574c04fb1a..3e9feccbf06 100644
--- a/generated/src/aws-cpp-sdk-comprehend/source/ComprehendErrors.cpp
+++ b/generated/src/aws-cpp-sdk-comprehend/source/ComprehendErrors.cpp
@@ -4,15 +4,25 @@
  */
 
 #include <aws/comprehend/ComprehendErrors.h>
+#include <aws/comprehend/model/InvalidRequestException.h>
 #include <aws/core/client/AWSError.h>
 #include <aws/core/utils/HashingUtils.h>
+#include <aws/core/utils/cbor/CborValue.h>
 
 using namespace Aws::Client;
 using namespace Aws::Utils;
 using namespace Aws::Comprehend;
+using namespace Aws::Comprehend::Model;
 
 namespace Aws {
 namespace Comprehend {
+template <>
+AWS_COMPREHEND_API InvalidRequestException ComprehendError::GetModeledError() {
+  assert(this->GetErrorType() == ComprehendErrors::INVALID_REQUEST);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return InvalidRequestException(payload.GetDecoder());
+}
+
 namespace ComprehendErrorMapper {
 
 static const int UNSUPPORTED_LANGUAGE_HASH = HashingUtils::HashString("UnsupportedLanguageException");
diff --git a/generated/src/aws-cpp-sdk-datasync/source/DataSyncErrors.cpp b/generated/src/aws-cpp-sdk-datasync/source/DataSyncErrors.cpp
index 277c5f8a3c3..ef52bb2816a 100644
--- a/generated/src/aws-cpp-sdk-datasync/source/DataSyncErrors.cpp
+++ b/generated/src/aws-cpp-sdk-datasync/source/DataSyncErrors.cpp
@@ -5,14 +5,32 @@
 
 #include <aws/core/client/AWSError.h>
 #include <aws/core/utils/HashingUtils.h>
+#include <aws/core/utils/cbor/CborValue.h>
 #include <aws/datasync/DataSyncErrors.h>
+#include <aws/datasync/model/InternalException.h>
+#include <aws/datasync/model/InvalidRequestException.h>
 
 using namespace Aws::Client;
 using namespace Aws::Utils;
 using namespace Aws::DataSync;
+using namespace Aws::DataSync::Model;
 
 namespace Aws {
 namespace DataSync {
+template <>
+AWS_DATASYNC_API InternalException DataSyncError::GetModeledError() {
+  assert(this->GetErrorType() == DataSyncErrors::INTERNAL);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return InternalException(payload.GetDecoder());
+}
+
+template <>
+AWS_DATASYNC_API InvalidRequestException DataSyncError::GetModeledError() {
+  assert(this->GetErrorType() == DataSyncErrors::INVALID_REQUEST);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return InvalidRequestException(payload.GetDecoder());
+}
+
 namespace DataSyncErrorMapper {
 
 static const int INTERNAL_HASH = HashingUtils::HashString("InternalException");
diff --git a/generated/src/aws-cpp-sdk-ds/source/DirectoryServiceErrors.cpp b/generated/src/aws-cpp-sdk-ds/source/DirectoryServiceErrors.cpp
index b5475b12ff9..836025754ca 100644
--- a/generated/src/aws-cpp-sdk-ds/source/DirectoryServiceErrors.cpp
+++ b/generated/src/aws-cpp-sdk-ds/source/DirectoryServiceErrors.cpp
@@ -5,14 +5,336 @@
 
 #include <aws/core/client/AWSError.h>
 #include <aws/core/utils/HashingUtils.h>
+#include <aws/core/utils/cbor/CborValue.h>
 #include <aws/ds/DirectoryServiceErrors.h>
+#include <aws/ds/model/ADAssessmentLimitExceededException.h>
+#include <aws/ds/model/AccessDeniedException.h>
+#include <aws/ds/model/AuthenticationFailedException.h>
+#include <aws/ds/model/CertificateAlreadyExistsException.h>
+#include <aws/ds/model/CertificateDoesNotExistException.h>
+#include <aws/ds/model/CertificateInUseException.h>
+#include <aws/ds/model/CertificateLimitExceededException.h>
+#include <aws/ds/model/ClientException.h>
+#include <aws/ds/model/DirectoryAlreadyInRegionException.h>
+#include <aws/ds/model/DirectoryAlreadySharedException.h>
+#include <aws/ds/model/DirectoryDoesNotExistException.h>
+#include <aws/ds/model/DirectoryInDesiredStateException.h>
+#include <aws/ds/model/DirectoryLimitExceededException.h>
+#include <aws/ds/model/DirectoryNotSharedException.h>
+#include <aws/ds/model/DirectoryUnavailableException.h>
+#include <aws/ds/model/DisableAlreadyInProgressException.h>
+#include <aws/ds/model/DomainControllerLimitExceededException.h>
+#include <aws/ds/model/EnableAlreadyInProgressException.h>
+#include <aws/ds/model/EntityAlreadyExistsException.h>
+#include <aws/ds/model/EntityDoesNotExistException.h>
+#include <aws/ds/model/IncompatibleSettingsException.h>
+#include <aws/ds/model/InsufficientPermissionsException.h>
+#include <aws/ds/model/InvalidCertificateException.h>
+#include <aws/ds/model/InvalidClientAuthStatusException.h>
+#include <aws/ds/model/InvalidLDAPSStatusException.h>
+#include <aws/ds/model/InvalidNextTokenException.h>
+#include <aws/ds/model/InvalidParameterException.h>
+#include <aws/ds/model/InvalidPasswordException.h>
+#include <aws/ds/model/InvalidTargetException.h>
+#include <aws/ds/model/IpRouteLimitExceededException.h>
+#include <aws/ds/model/NoAvailableCertificateException.h>
+#include <aws/ds/model/OrganizationsException.h>
+#include <aws/ds/model/RegionLimitExceededException.h>
+#include <aws/ds/model/ServiceException.h>
+#include <aws/ds/model/ShareLimitExceededException.h>
+#include <aws/ds/model/SnapshotLimitExceededException.h>
+#include <aws/ds/model/TagLimitExceededException.h>
+#include <aws/ds/model/UnsupportedOperationException.h>
+#include <aws/ds/model/UnsupportedSettingsException.h>
+#include <aws/ds/model/UserDoesNotExistException.h>
 
 using namespace Aws::Client;
 using namespace Aws::Utils;
 using namespace Aws::DirectoryService;
+using namespace Aws::DirectoryService::Model;
 
 namespace Aws {
 namespace DirectoryService {
+template <>
+AWS_DIRECTORYSERVICE_API ClientException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::CLIENT);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ClientException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API EntityAlreadyExistsException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::ENTITY_ALREADY_EXISTS);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return EntityAlreadyExistsException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API DisableAlreadyInProgressException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::DISABLE_ALREADY_IN_PROGRESS);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return DisableAlreadyInProgressException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API UnsupportedSettingsException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::UNSUPPORTED_SETTINGS);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return UnsupportedSettingsException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API DirectoryAlreadySharedException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::DIRECTORY_ALREADY_SHARED);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return DirectoryAlreadySharedException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API DirectoryAlreadyInRegionException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::DIRECTORY_ALREADY_IN_REGION);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return DirectoryAlreadyInRegionException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API InvalidLDAPSStatusException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::INVALID_L_D_A_P_S_STATUS);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return InvalidLDAPSStatusException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API DirectoryUnavailableException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::DIRECTORY_UNAVAILABLE);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return DirectoryUnavailableException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API UserDoesNotExistException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::USER_DOES_NOT_EXIST);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return UserDoesNotExistException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API EntityDoesNotExistException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::ENTITY_DOES_NOT_EXIST);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return EntityDoesNotExistException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API AuthenticationFailedException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::AUTHENTICATION_FAILED);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return AuthenticationFailedException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API EnableAlreadyInProgressException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::ENABLE_ALREADY_IN_PROGRESS);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return EnableAlreadyInProgressException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API InsufficientPermissionsException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::INSUFFICIENT_PERMISSIONS);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return InsufficientPermissionsException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API InvalidNextTokenException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::INVALID_NEXT_TOKEN);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return InvalidNextTokenException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API DirectoryInDesiredStateException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::DIRECTORY_IN_DESIRED_STATE);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return DirectoryInDesiredStateException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API ADAssessmentLimitExceededException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::A_D_ASSESSMENT_LIMIT_EXCEEDED);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ADAssessmentLimitExceededException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API InvalidParameterException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::INVALID_PARAMETER);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return InvalidParameterException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API TagLimitExceededException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::TAG_LIMIT_EXCEEDED);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return TagLimitExceededException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API InvalidCertificateException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::INVALID_CERTIFICATE);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return InvalidCertificateException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API AccessDeniedException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::ACCESS_DENIED);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return AccessDeniedException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API UnsupportedOperationException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::UNSUPPORTED_OPERATION);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return UnsupportedOperationException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API CertificateDoesNotExistException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::CERTIFICATE_DOES_NOT_EXIST);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return CertificateDoesNotExistException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API CertificateAlreadyExistsException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::CERTIFICATE_ALREADY_EXISTS);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return CertificateAlreadyExistsException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API InvalidPasswordException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::INVALID_PASSWORD);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return InvalidPasswordException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API IncompatibleSettingsException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::INCOMPATIBLE_SETTINGS);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return IncompatibleSettingsException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API DirectoryLimitExceededException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::DIRECTORY_LIMIT_EXCEEDED);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return DirectoryLimitExceededException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API DirectoryNotSharedException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::DIRECTORY_NOT_SHARED);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return DirectoryNotSharedException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API CertificateInUseException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::CERTIFICATE_IN_USE);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return CertificateInUseException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API ShareLimitExceededException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::SHARE_LIMIT_EXCEEDED);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ShareLimitExceededException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API DirectoryDoesNotExistException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::DIRECTORY_DOES_NOT_EXIST);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return DirectoryDoesNotExistException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API NoAvailableCertificateException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::NO_AVAILABLE_CERTIFICATE);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return NoAvailableCertificateException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API InvalidClientAuthStatusException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::INVALID_CLIENT_AUTH_STATUS);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return InvalidClientAuthStatusException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API OrganizationsException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::ORGANIZATIONS);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return OrganizationsException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API InvalidTargetException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::INVALID_TARGET);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return InvalidTargetException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API DomainControllerLimitExceededException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::DOMAIN_CONTROLLER_LIMIT_EXCEEDED);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return DomainControllerLimitExceededException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API RegionLimitExceededException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::REGION_LIMIT_EXCEEDED);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return RegionLimitExceededException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API ServiceException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::SERVICE);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ServiceException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API IpRouteLimitExceededException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::IP_ROUTE_LIMIT_EXCEEDED);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return IpRouteLimitExceededException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API SnapshotLimitExceededException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::SNAPSHOT_LIMIT_EXCEEDED);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return SnapshotLimitExceededException(payload.GetDecoder());
+}
+
+template <>
+AWS_DIRECTORYSERVICE_API CertificateLimitExceededException DirectoryServiceError::GetModeledError() {
+  assert(this->GetErrorType() == DirectoryServiceErrors::CERTIFICATE_LIMIT_EXCEEDED);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return CertificateLimitExceededException(payload.GetDecoder());
+}
+
 namespace DirectoryServiceErrorMapper {
 
 static const int CLIENT_HASH = HashingUtils::HashString("ClientException");
diff --git a/generated/src/aws-cpp-sdk-keyspaces/source/KeyspacesErrors.cpp b/generated/src/aws-cpp-sdk-keyspaces/source/KeyspacesErrors.cpp
index a7d796d8769..1192091857d 100644
--- a/generated/src/aws-cpp-sdk-keyspaces/source/KeyspacesErrors.cpp
+++ b/generated/src/aws-cpp-sdk-keyspaces/source/KeyspacesErrors.cpp
@@ -5,14 +5,24 @@
 
 #include <aws/core/client/AWSError.h>
 #include <aws/core/utils/HashingUtils.h>
+#include <aws/core/utils/cbor/CborValue.h>
 #include <aws/keyspaces/KeyspacesErrors.h>
+#include <aws/keyspaces/model/ResourceNotFoundException.h>
 
 using namespace Aws::Client;
 using namespace Aws::Utils;
 using namespace Aws::Keyspaces;
+using namespace Aws::Keyspaces::Model;
 
 namespace Aws {
 namespace Keyspaces {
+template <>
+AWS_KEYSPACES_API ResourceNotFoundException KeyspacesError::GetModeledError() {
+  assert(this->GetErrorType() == KeyspacesErrors::RESOURCE_NOT_FOUND);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ResourceNotFoundException(payload.GetDecoder());
+}
+
 namespace KeyspacesErrorMapper {
 
 static const int CONFLICT_HASH = HashingUtils::HashString("ConflictException");
diff --git a/generated/src/aws-cpp-sdk-marketplace-agreement/source/AgreementServiceErrors.cpp b/generated/src/aws-cpp-sdk-marketplace-agreement/source/AgreementServiceErrors.cpp
index 3a2a3040023..adac6a69bec 100644
--- a/generated/src/aws-cpp-sdk-marketplace-agreement/source/AgreementServiceErrors.cpp
+++ b/generated/src/aws-cpp-sdk-marketplace-agreement/source/AgreementServiceErrors.cpp
@@ -5,14 +5,72 @@
 
 #include <aws/core/client/AWSError.h>
 #include <aws/core/utils/HashingUtils.h>
+#include <aws/core/utils/cbor/CborValue.h>
 #include <aws/marketplace-agreement/AgreementServiceErrors.h>
+#include <aws/marketplace-agreement/model/AccessDeniedException.h>
+#include <aws/marketplace-agreement/model/ConflictException.h>
+#include <aws/marketplace-agreement/model/InternalServerException.h>
+#include <aws/marketplace-agreement/model/ResourceNotFoundException.h>
+#include <aws/marketplace-agreement/model/ServiceQuotaExceededException.h>
+#include <aws/marketplace-agreement/model/ThrottlingException.h>
+#include <aws/marketplace-agreement/model/ValidationException.h>
 
 using namespace Aws::Client;
 using namespace Aws::Utils;
 using namespace Aws::AgreementService;
+using namespace Aws::AgreementService::Model;
 
 namespace Aws {
 namespace AgreementService {
+template <>
+AWS_AGREEMENTSERVICE_API ConflictException AgreementServiceError::GetModeledError() {
+  assert(this->GetErrorType() == AgreementServiceErrors::CONFLICT);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ConflictException(payload.GetDecoder());
+}
+
+template <>
+AWS_AGREEMENTSERVICE_API ThrottlingException AgreementServiceError::GetModeledError() {
+  assert(this->GetErrorType() == AgreementServiceErrors::THROTTLING);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ThrottlingException(payload.GetDecoder());
+}
+
+template <>
+AWS_AGREEMENTSERVICE_API ServiceQuotaExceededException AgreementServiceError::GetModeledError() {
+  assert(this->GetErrorType() == AgreementServiceErrors::SERVICE_QUOTA_EXCEEDED);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ServiceQuotaExceededException(payload.GetDecoder());
+}
+
+template <>
+AWS_AGREEMENTSERVICE_API ResourceNotFoundException AgreementServiceError::GetModeledError() {
+  assert(this->GetErrorType() == AgreementServiceErrors::RESOURCE_NOT_FOUND);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ResourceNotFoundException(payload.GetDecoder());
+}
+
+template <>
+AWS_AGREEMENTSERVICE_API InternalServerException AgreementServiceError::GetModeledError() {
+  assert(this->GetErrorType() == AgreementServiceErrors::INTERNAL_SERVER);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return InternalServerException(payload.GetDecoder());
+}
+
+template <>
+AWS_AGREEMENTSERVICE_API ValidationException AgreementServiceError::GetModeledError() {
+  assert(this->GetErrorType() == AgreementServiceErrors::VALIDATION);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ValidationException(payload.GetDecoder());
+}
+
+template <>
+AWS_AGREEMENTSERVICE_API AccessDeniedException AgreementServiceError::GetModeledError() {
+  assert(this->GetErrorType() == AgreementServiceErrors::ACCESS_DENIED);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return AccessDeniedException(payload.GetDecoder());
+}
+
 namespace AgreementServiceErrorMapper {
 
 static const int CONFLICT_HASH = HashingUtils::HashString("ConflictException");
diff --git a/generated/src/aws-cpp-sdk-monitoring/source/CloudWatchErrors.cpp b/generated/src/aws-cpp-sdk-monitoring/source/CloudWatchErrors.cpp
index 6175b735ef8..57fb4e118ff 100644
--- a/generated/src/aws-cpp-sdk-monitoring/source/CloudWatchErrors.cpp
+++ b/generated/src/aws-cpp-sdk-monitoring/source/CloudWatchErrors.cpp
@@ -5,14 +5,32 @@
 
 #include <aws/core/client/AWSError.h>
 #include <aws/core/utils/HashingUtils.h>
+#include <aws/core/utils/cbor/CborValue.h>
 #include <aws/monitoring/CloudWatchErrors.h>
+#include <aws/monitoring/model/DashboardInvalidInputError.h>
+#include <aws/monitoring/model/ResourceNotFoundException.h>
 
 using namespace Aws::Client;
 using namespace Aws::Utils;
 using namespace Aws::CloudWatch;
+using namespace Aws::CloudWatch::Model;
 
 namespace Aws {
 namespace CloudWatch {
+template <>
+AWS_CLOUDWATCH_API ResourceNotFoundException CloudWatchError::GetModeledError() {
+  assert(this->GetErrorType() == CloudWatchErrors::RESOURCE_NOT_FOUND);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ResourceNotFoundException(payload.GetDecoder());
+}
+
+template <>
+AWS_CLOUDWATCH_API DashboardInvalidInputError CloudWatchError::GetModeledError() {
+  assert(this->GetErrorType() == CloudWatchErrors::DASHBOARD_INVALID_INPUT);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return DashboardInvalidInputError(payload.GetDecoder());
+}
+
 namespace CloudWatchErrorMapper {
 
 static const int CONFLICT_HASH = HashingUtils::HashString("ConflictException");
diff --git a/generated/src/aws-cpp-sdk-partnercentral-revenue-measurement/source/PartnerCentralRevenueMeasurementErrors.cpp b/generated/src/aws-cpp-sdk-partnercentral-revenue-measurement/source/PartnerCentralRevenueMeasurementErrors.cpp
index 6e2b522730a..59e51c8bafb 100644
--- a/generated/src/aws-cpp-sdk-partnercentral-revenue-measurement/source/PartnerCentralRevenueMeasurementErrors.cpp
+++ b/generated/src/aws-cpp-sdk-partnercentral-revenue-measurement/source/PartnerCentralRevenueMeasurementErrors.cpp
@@ -5,14 +5,64 @@
 
 #include <aws/core/client/AWSError.h>
 #include <aws/core/utils/HashingUtils.h>
+#include <aws/core/utils/cbor/CborValue.h>
 #include <aws/partnercentral-revenue-measurement/PartnerCentralRevenueMeasurementErrors.h>
+#include <aws/partnercentral-revenue-measurement/model/AccessDeniedException.h>
+#include <aws/partnercentral-revenue-measurement/model/ConflictException.h>
+#include <aws/partnercentral-revenue-measurement/model/ResourceNotFoundException.h>
+#include <aws/partnercentral-revenue-measurement/model/ServiceQuotaExceededException.h>
+#include <aws/partnercentral-revenue-measurement/model/ThrottlingException.h>
+#include <aws/partnercentral-revenue-measurement/model/ValidationException.h>
 
 using namespace Aws::Client;
 using namespace Aws::Utils;
 using namespace Aws::PartnerCentralRevenueMeasurement;
+using namespace Aws::PartnerCentralRevenueMeasurement::Model;
 
 namespace Aws {
 namespace PartnerCentralRevenueMeasurement {
+template <>
+AWS_PARTNERCENTRALREVENUEMEASUREMENT_API ConflictException PartnerCentralRevenueMeasurementError::GetModeledError() {
+  assert(this->GetErrorType() == PartnerCentralRevenueMeasurementErrors::CONFLICT);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ConflictException(payload.GetDecoder());
+}
+
+template <>
+AWS_PARTNERCENTRALREVENUEMEASUREMENT_API ServiceQuotaExceededException PartnerCentralRevenueMeasurementError::GetModeledError() {
+  assert(this->GetErrorType() == PartnerCentralRevenueMeasurementErrors::SERVICE_QUOTA_EXCEEDED);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ServiceQuotaExceededException(payload.GetDecoder());
+}
+
+template <>
+AWS_PARTNERCENTRALREVENUEMEASUREMENT_API ThrottlingException PartnerCentralRevenueMeasurementError::GetModeledError() {
+  assert(this->GetErrorType() == PartnerCentralRevenueMeasurementErrors::THROTTLING);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ThrottlingException(payload.GetDecoder());
+}
+
+template <>
+AWS_PARTNERCENTRALREVENUEMEASUREMENT_API ResourceNotFoundException PartnerCentralRevenueMeasurementError::GetModeledError() {
+  assert(this->GetErrorType() == PartnerCentralRevenueMeasurementErrors::RESOURCE_NOT_FOUND);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ResourceNotFoundException(payload.GetDecoder());
+}
+
+template <>
+AWS_PARTNERCENTRALREVENUEMEASUREMENT_API ValidationException PartnerCentralRevenueMeasurementError::GetModeledError() {
+  assert(this->GetErrorType() == PartnerCentralRevenueMeasurementErrors::VALIDATION);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ValidationException(payload.GetDecoder());
+}
+
+template <>
+AWS_PARTNERCENTRALREVENUEMEASUREMENT_API AccessDeniedException PartnerCentralRevenueMeasurementError::GetModeledError() {
+  assert(this->GetErrorType() == PartnerCentralRevenueMeasurementErrors::ACCESS_DENIED);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return AccessDeniedException(payload.GetDecoder());
+}
+
 namespace PartnerCentralRevenueMeasurementErrorMapper {
 
 static const int CONFLICT_HASH = HashingUtils::HashString("ConflictException");
diff --git a/generated/src/aws-cpp-sdk-route53domains/source/Route53DomainsErrors.cpp b/generated/src/aws-cpp-sdk-route53domains/source/Route53DomainsErrors.cpp
index d2a4ba5fad8..5bea4bd9043 100644
--- a/generated/src/aws-cpp-sdk-route53domains/source/Route53DomainsErrors.cpp
+++ b/generated/src/aws-cpp-sdk-route53domains/source/Route53DomainsErrors.cpp
@@ -5,14 +5,32 @@
 
 #include <aws/core/client/AWSError.h>
 #include <aws/core/utils/HashingUtils.h>
+#include <aws/core/utils/cbor/CborValue.h>
 #include <aws/route53domains/Route53DomainsErrors.h>
+#include <aws/route53domains/model/DuplicateRequest.h>
+#include <aws/route53domains/model/TLDInMaintenance.h>
 
 using namespace Aws::Client;
 using namespace Aws::Utils;
 using namespace Aws::Route53Domains;
+using namespace Aws::Route53Domains::Model;
 
 namespace Aws {
 namespace Route53Domains {
+template <>
+AWS_ROUTE53DOMAINS_API DuplicateRequest Route53DomainsError::GetModeledError() {
+  assert(this->GetErrorType() == Route53DomainsErrors::DUPLICATE_REQUEST);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return DuplicateRequest(payload.GetDecoder());
+}
+
+template <>
+AWS_ROUTE53DOMAINS_API TLDInMaintenance Route53DomainsError::GetModeledError() {
+  assert(this->GetErrorType() == Route53DomainsErrors::T_L_D_IN_MAINTENANCE);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return TLDInMaintenance(payload.GetDecoder());
+}
+
 namespace Route53DomainsErrorMapper {
 
 static const int INVALID_INPUT_HASH = HashingUtils::HashString("InvalidInput");
diff --git a/generated/src/aws-cpp-sdk-servicediscovery/source/ServiceDiscoveryErrors.cpp b/generated/src/aws-cpp-sdk-servicediscovery/source/ServiceDiscoveryErrors.cpp
index e3c7e2ae59c..50534d0ae51 100644
--- a/generated/src/aws-cpp-sdk-servicediscovery/source/ServiceDiscoveryErrors.cpp
+++ b/generated/src/aws-cpp-sdk-servicediscovery/source/ServiceDiscoveryErrors.cpp
@@ -5,14 +5,48 @@
 
 #include <aws/core/client/AWSError.h>
 #include <aws/core/utils/HashingUtils.h>
+#include <aws/core/utils/cbor/CborValue.h>
 #include <aws/servicediscovery/ServiceDiscoveryErrors.h>
+#include <aws/servicediscovery/model/DuplicateRequest.h>
+#include <aws/servicediscovery/model/NamespaceAlreadyExists.h>
+#include <aws/servicediscovery/model/ServiceAlreadyExists.h>
+#include <aws/servicediscovery/model/TooManyTagsException.h>
 
 using namespace Aws::Client;
 using namespace Aws::Utils;
 using namespace Aws::ServiceDiscovery;
+using namespace Aws::ServiceDiscovery::Model;
 
 namespace Aws {
 namespace ServiceDiscovery {
+template <>
+AWS_SERVICEDISCOVERY_API NamespaceAlreadyExists ServiceDiscoveryError::GetModeledError() {
+  assert(this->GetErrorType() == ServiceDiscoveryErrors::NAMESPACE_ALREADY_EXISTS);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return NamespaceAlreadyExists(payload.GetDecoder());
+}
+
+template <>
+AWS_SERVICEDISCOVERY_API DuplicateRequest ServiceDiscoveryError::GetModeledError() {
+  assert(this->GetErrorType() == ServiceDiscoveryErrors::DUPLICATE_REQUEST);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return DuplicateRequest(payload.GetDecoder());
+}
+
+template <>
+AWS_SERVICEDISCOVERY_API ServiceAlreadyExists ServiceDiscoveryError::GetModeledError() {
+  assert(this->GetErrorType() == ServiceDiscoveryErrors::SERVICE_ALREADY_EXISTS);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ServiceAlreadyExists(payload.GetDecoder());
+}
+
+template <>
+AWS_SERVICEDISCOVERY_API TooManyTagsException ServiceDiscoveryError::GetModeledError() {
+  assert(this->GetErrorType() == ServiceDiscoveryErrors::TOO_MANY_TAGS);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return TooManyTagsException(payload.GetDecoder());
+}
+
 namespace ServiceDiscoveryErrorMapper {
 
 static const int NAMESPACE_ALREADY_EXISTS_HASH = HashingUtils::HashString("NamespaceAlreadyExists");
diff --git a/generated/src/aws-cpp-sdk-shield/source/ShieldErrors.cpp b/generated/src/aws-cpp-sdk-shield/source/ShieldErrors.cpp
index 2544e0c2639..f16c5bae6a3 100644
--- a/generated/src/aws-cpp-sdk-shield/source/ShieldErrors.cpp
+++ b/generated/src/aws-cpp-sdk-shield/source/ShieldErrors.cpp
@@ -5,14 +5,48 @@
 
 #include <aws/core/client/AWSError.h>
 #include <aws/core/utils/HashingUtils.h>
+#include <aws/core/utils/cbor/CborValue.h>
 #include <aws/shield/ShieldErrors.h>
+#include <aws/shield/model/InvalidParameterException.h>
+#include <aws/shield/model/LimitsExceededException.h>
+#include <aws/shield/model/ResourceAlreadyExistsException.h>
+#include <aws/shield/model/ResourceNotFoundException.h>
 
 using namespace Aws::Client;
 using namespace Aws::Utils;
 using namespace Aws::Shield;
+using namespace Aws::Shield::Model;
 
 namespace Aws {
 namespace Shield {
+template <>
+AWS_SHIELD_API ResourceNotFoundException ShieldError::GetModeledError() {
+  assert(this->GetErrorType() == ShieldErrors::RESOURCE_NOT_FOUND);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ResourceNotFoundException(payload.GetDecoder());
+}
+
+template <>
+AWS_SHIELD_API ResourceAlreadyExistsException ShieldError::GetModeledError() {
+  assert(this->GetErrorType() == ShieldErrors::RESOURCE_ALREADY_EXISTS);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ResourceAlreadyExistsException(payload.GetDecoder());
+}
+
+template <>
+AWS_SHIELD_API LimitsExceededException ShieldError::GetModeledError() {
+  assert(this->GetErrorType() == ShieldErrors::LIMITS_EXCEEDED);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return LimitsExceededException(payload.GetDecoder());
+}
+
+template <>
+AWS_SHIELD_API InvalidParameterException ShieldError::GetModeledError() {
+  assert(this->GetErrorType() == ShieldErrors::INVALID_PARAMETER);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return InvalidParameterException(payload.GetDecoder());
+}
+
 namespace ShieldErrorMapper {
 
 static const int INTERNAL_ERROR_HASH = HashingUtils::HashString("InternalErrorException");
diff --git a/generated/src/aws-cpp-sdk-snowball/source/SnowballErrors.cpp b/generated/src/aws-cpp-sdk-snowball/source/SnowballErrors.cpp
index 7a820e4d4d6..f93f11f71b2 100644
--- a/generated/src/aws-cpp-sdk-snowball/source/SnowballErrors.cpp
+++ b/generated/src/aws-cpp-sdk-snowball/source/SnowballErrors.cpp
@@ -5,14 +5,32 @@
 
 #include <aws/core/client/AWSError.h>
 #include <aws/core/utils/HashingUtils.h>
+#include <aws/core/utils/cbor/CborValue.h>
 #include <aws/snowball/SnowballErrors.h>
+#include <aws/snowball/model/ConflictException.h>
+#include <aws/snowball/model/InvalidResourceException.h>
 
 using namespace Aws::Client;
 using namespace Aws::Utils;
 using namespace Aws::Snowball;
+using namespace Aws::Snowball::Model;
 
 namespace Aws {
 namespace Snowball {
+template <>
+AWS_SNOWBALL_API ConflictException SnowballError::GetModeledError() {
+  assert(this->GetErrorType() == SnowballErrors::CONFLICT);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ConflictException(payload.GetDecoder());
+}
+
+template <>
+AWS_SNOWBALL_API InvalidResourceException SnowballError::GetModeledError() {
+  assert(this->GetErrorType() == SnowballErrors::INVALID_RESOURCE);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return InvalidResourceException(payload.GetDecoder());
+}
+
 namespace SnowballErrorMapper {
 
 static const int CLUSTER_LIMIT_EXCEEDED_HASH = HashingUtils::HashString("ClusterLimitExceededException");
diff --git a/generated/src/aws-cpp-sdk-textract/source/TextractErrors.cpp b/generated/src/aws-cpp-sdk-textract/source/TextractErrors.cpp
index 7e90854766b..1558274d0d3 100644
--- a/generated/src/aws-cpp-sdk-textract/source/TextractErrors.cpp
+++ b/generated/src/aws-cpp-sdk-textract/source/TextractErrors.cpp
@@ -5,14 +5,24 @@
 
 #include <aws/core/client/AWSError.h>
 #include <aws/core/utils/HashingUtils.h>
+#include <aws/core/utils/cbor/CborValue.h>
 #include <aws/textract/TextractErrors.h>
+#include <aws/textract/model/HumanLoopQuotaExceededException.h>
 
 using namespace Aws::Client;
 using namespace Aws::Utils;
 using namespace Aws::Textract;
+using namespace Aws::Textract::Model;
 
 namespace Aws {
 namespace Textract {
+template <>
+AWS_TEXTRACT_API HumanLoopQuotaExceededException TextractError::GetModeledError() {
+  assert(this->GetErrorType() == TextractErrors::HUMAN_LOOP_QUOTA_EXCEEDED);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return HumanLoopQuotaExceededException(payload.GetDecoder());
+}
+
 namespace TextractErrorMapper {
 
 static const int CONFLICT_HASH = HashingUtils::HashString("ConflictException");
diff --git a/generated/src/aws-cpp-sdk-translate/source/TranslateErrors.cpp b/generated/src/aws-cpp-sdk-translate/source/TranslateErrors.cpp
index e77f7a1b006..23186be15db 100644
--- a/generated/src/aws-cpp-sdk-translate/source/TranslateErrors.cpp
+++ b/generated/src/aws-cpp-sdk-translate/source/TranslateErrors.cpp
@@ -5,14 +5,48 @@
 
 #include <aws/core/client/AWSError.h>
 #include <aws/core/utils/HashingUtils.h>
+#include <aws/core/utils/cbor/CborValue.h>
 #include <aws/translate/TranslateErrors.h>
+#include <aws/translate/model/DetectedLanguageLowConfidenceException.h>
+#include <aws/translate/model/TooManyTagsException.h>
+#include <aws/translate/model/UnsupportedDisplayLanguageCodeException.h>
+#include <aws/translate/model/UnsupportedLanguagePairException.h>
 
 using namespace Aws::Client;
 using namespace Aws::Utils;
 using namespace Aws::Translate;
+using namespace Aws::Translate::Model;
 
 namespace Aws {
 namespace Translate {
+template <>
+AWS_TRANSLATE_API UnsupportedLanguagePairException TranslateError::GetModeledError() {
+  assert(this->GetErrorType() == TranslateErrors::UNSUPPORTED_LANGUAGE_PAIR);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return UnsupportedLanguagePairException(payload.GetDecoder());
+}
+
+template <>
+AWS_TRANSLATE_API DetectedLanguageLowConfidenceException TranslateError::GetModeledError() {
+  assert(this->GetErrorType() == TranslateErrors::DETECTED_LANGUAGE_LOW_CONFIDENCE);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return DetectedLanguageLowConfidenceException(payload.GetDecoder());
+}
+
+template <>
+AWS_TRANSLATE_API UnsupportedDisplayLanguageCodeException TranslateError::GetModeledError() {
+  assert(this->GetErrorType() == TranslateErrors::UNSUPPORTED_DISPLAY_LANGUAGE_CODE);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return UnsupportedDisplayLanguageCodeException(payload.GetDecoder());
+}
+
+template <>
+AWS_TRANSLATE_API TooManyTagsException TranslateError::GetModeledError() {
+  assert(this->GetErrorType() == TranslateErrors::TOO_MANY_TAGS);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return TooManyTagsException(payload.GetDecoder());
+}
+
 namespace TranslateErrorMapper {
 
 static const int CONFLICT_HASH = HashingUtils::HashString("ConflictException");
diff --git a/generated/src/aws-cpp-sdk-workspaces-instances/source/WorkspacesInstancesErrors.cpp b/generated/src/aws-cpp-sdk-workspaces-instances/source/WorkspacesInstancesErrors.cpp
index 9bb7430e9d6..c0deca92cb4 100644
--- a/generated/src/aws-cpp-sdk-workspaces-instances/source/WorkspacesInstancesErrors.cpp
+++ b/generated/src/aws-cpp-sdk-workspaces-instances/source/WorkspacesInstancesErrors.cpp
@@ -5,14 +5,72 @@
 
 #include <aws/core/client/AWSError.h>
 #include <aws/core/utils/HashingUtils.h>
+#include <aws/core/utils/cbor/CborValue.h>
 #include <aws/workspaces-instances/WorkspacesInstancesErrors.h>
+#include <aws/workspaces-instances/model/ConflictException.h>
+#include <aws/workspaces-instances/model/InternalServerException.h>
+#include <aws/workspaces-instances/model/ResourceNotFoundException.h>
+#include <aws/workspaces-instances/model/ServiceQuotaExceededException.h>
+#include <aws/workspaces-instances/model/ThrottlingException.h>
+#include <aws/workspaces-instances/model/ValidationException.h>
+#include <aws/workspaces-instances/model/VolumeModificationRateExceededException.h>
 
 using namespace Aws::Client;
 using namespace Aws::Utils;
 using namespace Aws::WorkspacesInstances;
+using namespace Aws::WorkspacesInstances::Model;
 
 namespace Aws {
 namespace WorkspacesInstances {
+template <>
+AWS_WORKSPACESINSTANCES_API ConflictException WorkspacesInstancesError::GetModeledError() {
+  assert(this->GetErrorType() == WorkspacesInstancesErrors::CONFLICT);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ConflictException(payload.GetDecoder());
+}
+
+template <>
+AWS_WORKSPACESINSTANCES_API ThrottlingException WorkspacesInstancesError::GetModeledError() {
+  assert(this->GetErrorType() == WorkspacesInstancesErrors::THROTTLING);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ThrottlingException(payload.GetDecoder());
+}
+
+template <>
+AWS_WORKSPACESINSTANCES_API ServiceQuotaExceededException WorkspacesInstancesError::GetModeledError() {
+  assert(this->GetErrorType() == WorkspacesInstancesErrors::SERVICE_QUOTA_EXCEEDED);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ServiceQuotaExceededException(payload.GetDecoder());
+}
+
+template <>
+AWS_WORKSPACESINSTANCES_API VolumeModificationRateExceededException WorkspacesInstancesError::GetModeledError() {
+  assert(this->GetErrorType() == WorkspacesInstancesErrors::VOLUME_MODIFICATION_RATE_EXCEEDED);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return VolumeModificationRateExceededException(payload.GetDecoder());
+}
+
+template <>
+AWS_WORKSPACESINSTANCES_API ResourceNotFoundException WorkspacesInstancesError::GetModeledError() {
+  assert(this->GetErrorType() == WorkspacesInstancesErrors::RESOURCE_NOT_FOUND);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ResourceNotFoundException(payload.GetDecoder());
+}
+
+template <>
+AWS_WORKSPACESINSTANCES_API InternalServerException WorkspacesInstancesError::GetModeledError() {
+  assert(this->GetErrorType() == WorkspacesInstancesErrors::INTERNAL_SERVER);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return InternalServerException(payload.GetDecoder());
+}
+
+template <>
+AWS_WORKSPACESINSTANCES_API ValidationException WorkspacesInstancesError::GetModeledError() {
+  assert(this->GetErrorType() == WorkspacesInstancesErrors::VALIDATION);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ValidationException(payload.GetDecoder());
+}
+
 namespace WorkspacesInstancesErrorMapper {
 
 static const int CONFLICT_HASH = HashingUtils::HashString("ConflictException");
diff --git a/generated/src/aws-cpp-sdk-workspaces/source/WorkSpacesErrors.cpp b/generated/src/aws-cpp-sdk-workspaces/source/WorkSpacesErrors.cpp
index 96b34836b93..0c9ce0865d4 100644
--- a/generated/src/aws-cpp-sdk-workspaces/source/WorkSpacesErrors.cpp
+++ b/generated/src/aws-cpp-sdk-workspaces/source/WorkSpacesErrors.cpp
@@ -5,14 +5,48 @@
 
 #include <aws/core/client/AWSError.h>
 #include <aws/core/utils/HashingUtils.h>
+#include <aws/core/utils/cbor/CborValue.h>
 #include <aws/workspaces/WorkSpacesErrors.h>
+#include <aws/workspaces/model/OperationNotSupportedException.h>
+#include <aws/workspaces/model/ResourceInUseException.h>
+#include <aws/workspaces/model/ResourceNotFoundException.h>
+#include <aws/workspaces/model/ResourceUnavailableException.h>
 
 using namespace Aws::Client;
 using namespace Aws::Utils;
 using namespace Aws::WorkSpaces;
+using namespace Aws::WorkSpaces::Model;
 
 namespace Aws {
 namespace WorkSpaces {
+template <>
+AWS_WORKSPACES_API ResourceNotFoundException WorkSpacesError::GetModeledError() {
+  assert(this->GetErrorType() == WorkSpacesErrors::RESOURCE_NOT_FOUND);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ResourceNotFoundException(payload.GetDecoder());
+}
+
+template <>
+AWS_WORKSPACES_API OperationNotSupportedException WorkSpacesError::GetModeledError() {
+  assert(this->GetErrorType() == WorkSpacesErrors::OPERATION_NOT_SUPPORTED);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return OperationNotSupportedException(payload.GetDecoder());
+}
+
+template <>
+AWS_WORKSPACES_API ResourceInUseException WorkSpacesError::GetModeledError() {
+  assert(this->GetErrorType() == WorkSpacesErrors::RESOURCE_IN_USE);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ResourceInUseException(payload.GetDecoder());
+}
+
+template <>
+AWS_WORKSPACES_API ResourceUnavailableException WorkSpacesError::GetModeledError() {
+  assert(this->GetErrorType() == WorkSpacesErrors::RESOURCE_UNAVAILABLE);
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ResourceUnavailableException(payload.GetDecoder());
+}
+
 namespace WorkSpacesErrorMapper {
 
 static const int CONFLICT_HASH = HashingUtils::HashString("ConflictException");
diff --git a/src/aws-cpp-sdk-core/include/aws/core/client/AWSError.h b/src/aws-cpp-sdk-core/include/aws/core/client/AWSError.h
index 69653735839..5c38fb9e247 100644
--- a/src/aws-cpp-sdk-core/include/aws/core/client/AWSError.h
+++ b/src/aws-cpp-sdk-core/include/aws/core/client/AWSError.h
@@ -19,12 +19,14 @@ namespace Aws
         enum class CoreErrors;
         class XmlErrorMarshaller;
         class JsonErrorMarshaller;
+        class RpcV2ErrorMarshaller;
 
         enum class ErrorPayloadType
         {
             NOT_SET,
             XML,
-            JSON
+            JSON,
+            CBOR
         };
 
         enum class RetryableType
@@ -44,6 +46,7 @@ namespace Aws
         friend class XmlErrorMarshaller;
         friend class JsonErrorMarshaller;
         friend class JsonErrorMarshallerQueryCompatible;
+        friend class RpcV2ErrorMarshaller;
         template<typename T> friend class AWSError;
         public:
             /**
@@ -103,6 +106,7 @@ namespace Aws
                 m_errorPayloadType(rhs.m_errorPayloadType),
                 m_xmlPayload(std::move(rhs.m_xmlPayload)),
                 m_jsonPayload(std::move(rhs.m_jsonPayload)),
+                m_cborPayload(std::move(rhs.m_cborPayload)),
                 m_retryableType(rhs.m_retryableType)
             {}
 
@@ -118,6 +122,7 @@ namespace Aws
                 m_errorPayloadType(rhs.m_errorPayloadType),
                 m_xmlPayload(rhs.m_xmlPayload),
                 m_jsonPayload(rhs.m_jsonPayload),
+                m_cborPayload(rhs.m_cborPayload),
                 m_retryableType(rhs.m_retryableType)
             {}
 
@@ -246,6 +251,16 @@ namespace Aws
                 assert(m_errorPayloadType != ErrorPayloadType::XML);
                 return m_jsonPayload;
             }
+            inline void SetCborPayload(Aws::String&& cborPayload)
+            {
+                m_errorPayloadType = ErrorPayloadType::CBOR;
+                m_cborPayload = std::move(cborPayload);
+            }
+            inline const Aws::String& GetCborPayload() const
+            {
+                assert(m_errorPayloadType != ErrorPayloadType::XML && m_errorPayloadType != ErrorPayloadType::JSON);
+                return m_cborPayload;
+            }
 
             ERROR_TYPE m_errorType;
             Aws::String m_exceptionName;
@@ -258,6 +273,7 @@ namespace Aws
             ErrorPayloadType m_errorPayloadType = ErrorPayloadType::NOT_SET;
             Aws::Utils::Xml::XmlDocument m_xmlPayload;
             Aws::Utils::Json::JsonValue m_jsonPayload;
+            Aws::String m_cborPayload;
             RetryableType m_retryableType;
         };
 
diff --git a/src/aws-cpp-sdk-core/source/client/AWSErrorMarshaller.cpp b/src/aws-cpp-sdk-core/source/client/AWSErrorMarshaller.cpp
index 1768fb9423b..178a2c4881b 100644
--- a/src/aws-cpp-sdk-core/source/client/AWSErrorMarshaller.cpp
+++ b/src/aws-cpp-sdk-core/source/client/AWSErrorMarshaller.cpp
@@ -413,7 +413,10 @@ CborValue RpcV2ErrorMarshaller::GetCborPayloadHttpResponse(const Http::HttpRespo
 }
 
 AWSError<CoreErrors> RpcV2ErrorMarshaller::Marshall(const Aws::Http::HttpResponse& httpResponse) const {
-  auto exceptionPayload = GetCborPayloadHttpResponse(httpResponse);
+  Aws::StringStream bodyStream;
+  bodyStream << httpResponse.GetResponseBody().rdbuf();
+  Aws::String body = bodyStream.str();
+  CborValue exceptionPayload(body);
   AWSError<CoreErrors> error;
 
   if (exceptionPayload.WasParseSuccessful()) {
@@ -494,6 +497,7 @@ AWSError<CoreErrors> RpcV2ErrorMarshaller::Marshall(const Aws::Http::HttpRespons
       error = FindErrorByHttpResponseCode(httpResponse.GetResponseCode());
       error.SetMessage(message);
     }
+    error.SetCborPayload(std::move(body));
   } else {
     bool isRetryable = IsRetryableHttpResponseCode(httpResponse.GetResponseCode());
     AWS_LOGSTREAM_ERROR(AWS_ERROR_MARSHALLER_LOG_TAG, "Failed to parse CBOR error payload: " << httpResponse.GetResponseCode());
diff --git a/tests/aws-cpp-sdk-core-tests/utils/OutcomeTest.cpp b/tests/aws-cpp-sdk-core-tests/utils/OutcomeTest.cpp
index 30dc23251be..50f9f6ef23b 100644
--- a/tests/aws-cpp-sdk-core-tests/utils/OutcomeTest.cpp
+++ b/tests/aws-cpp-sdk-core-tests/utils/OutcomeTest.cpp
@@ -13,6 +13,7 @@
 #include <aws/core/http/standard/StandardHttpResponse.h>
 #include <aws/core/utils/xml/XmlSerializer.h>
 #include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/utils/cbor/CborValue.h>
 #include <aws/core/AmazonWebServiceResult.h>
 #include <aws/core/NoResult.h>
 
@@ -255,6 +256,71 @@ class JsonServiceErrorMarshaller : public JsonErrorMarshaller
     }
 };
 
+class CborServiceSpecificException
+{
+public:
+    CborServiceSpecificException(const std::shared_ptr<Aws::Crt::Cbor::CborDecoder>& decoder)
+    {
+        auto mapSize = decoder->PopNextMapStart();
+        for (uint64_t i = 0; mapSize.has_value() && i < mapSize.value(); ++i)
+        {
+            auto key = decoder->PopNextTextVal();
+            if (key.has_value() && Aws::String(reinterpret_cast<const char*>(key.value().ptr), key.value().len) == "ExceptionInfo")
+            {
+                auto value = decoder->PopNextTextVal();
+                if (value.has_value())
+                {
+                    m_exceptionInfo = Aws::String(reinterpret_cast<const char*>(value.value().ptr), value.value().len);
+                }
+            }
+            else
+            {
+                decoder->ConsumeNextWholeDataItem();
+            }
+        }
+    }
+    inline const Aws::String& GetExceptionInfo() const{ return m_exceptionInfo; }
+private:
+    Aws::String m_exceptionInfo;
+};
+
+class CborServiceError : public Aws::Client::AWSError<ServiceErrors>
+{
+public:
+    CborServiceError() {}
+    CborServiceError(const Aws::Client::AWSError<Aws::Client::CoreErrors>& rhs) : Aws::Client::AWSError<ServiceErrors>(rhs) {}
+    CborServiceError(Aws::Client::AWSError<Aws::Client::CoreErrors>&& rhs) : Aws::Client::AWSError<ServiceErrors>(rhs) {}
+    CborServiceError(const Aws::Client::AWSError<ServiceErrors>& rhs) : Aws::Client::AWSError<ServiceErrors>(rhs) {}
+    CborServiceError(Aws::Client::AWSError<ServiceErrors>&& rhs) : Aws::Client::AWSError<ServiceErrors>(rhs) {}
+
+    template <typename T>
+    T GetModeledError();
+};
+
+template<>
+CborServiceSpecificException CborServiceError::GetModeledError()
+{
+    assert(this->GetErrorType() == ServiceErrors::SERVICE_SPECIFIC_EXCEPTION);
+    Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+    return CborServiceSpecificException(payload.GetDecoder());
+}
+
+class CborServiceErrorMarshaller : public RpcV2ErrorMarshaller
+{
+public:
+    AWSError<CoreErrors> FindErrorByName(const char* errorName) const override
+    {
+        if (Aws::String(errorName) == Aws::String("ServiceSpecificException"))
+        {
+            return AWSError<CoreErrors>(static_cast<CoreErrors>(ServiceErrors::SERVICE_SPECIFIC_EXCEPTION), false);
+        }
+        else
+        {
+            return AWSErrorMarshaller::FindErrorByName(errorName);
+        }
+    }
+};
+
 static std::shared_ptr<HttpResponse> CreateHttpResponse(const char* payloadString = "", HttpResponseCode httpResponseCode = HttpResponseCode::OK)
 {
     std::shared_ptr<HttpRequest> httpRequest = CreateHttpRequest(URI("http://www.uri.com/path/to/res"),
@@ -268,6 +334,23 @@ static std::shared_ptr<HttpResponse> CreateHttpResponse(const char* payloadStrin
     return httpResponse;
 }
 
+static std::shared_ptr<HttpResponse> CreateCborErrorHttpResponse()
+{
+    Aws::Crt::Cbor::CborEncoder encoder;
+    encoder.WriteMapStart(3);
+    encoder.WriteText(Aws::Crt::ByteCursorFromCString("__type"));
+    encoder.WriteText(Aws::Crt::ByteCursorFromCString("ServiceSpecificException"));
+    encoder.WriteText(Aws::Crt::ByteCursorFromCString("message"));
+    encoder.WriteText(Aws::Crt::ByteCursorFromCString(ERROR_MESSAGE));
+    encoder.WriteText(Aws::Crt::ByteCursorFromCString("ExceptionInfo"));
+    encoder.WriteText(Aws::Crt::ByteCursorFromCString("Detailed info"));
+    auto encodedData = encoder.GetEncodedData();
+
+    auto httpResponse = CreateHttpResponse("", HttpResponseCode::BAD_REQUEST);
+    httpResponse->GetResponseBody().write(reinterpret_cast<const char*>(encodedData.ptr), encodedData.len);
+    return httpResponse;
+}
+
 template<typename PAYLOAD_TYPE>
 static AmazonWebServiceResult<PAYLOAD_TYPE> CreateAmazonWebServiceResult(PAYLOAD_TYPE payload, HttpResponseCode httpResponseCode)
 {
@@ -290,6 +373,8 @@ typedef Outcome<XmlServiceOperationResult, XmlServiceError> XmlServiceOperationO
 typedef Outcome<JsonServiceOperationResult, JsonServiceError> JsonServiceOperationOutcome;
 typedef Outcome<NoResult, XmlServiceError> XmlServiceNoResultOperationOutcome;
 typedef Outcome<NoResult, JsonServiceError> JsonServiceNoResultOperationOutcome;
+typedef Outcome<AmazonWebServiceResult<Cbor::CborValue>, AWSError<CoreErrors>> CborOutcome;
+typedef Outcome<NoResult, CborServiceError> CborServiceNoResultOperationOutcome;
 
 class OutcomeTest : public Aws::Testing::AwsCppSdkGTestSuite
 {
@@ -467,4 +552,17 @@ TEST_F(OutcomeTest, JsonServiceNoResultOperationOutcomeTestMoveFromJsonOutcome)
     ASSERT_STREQ("ServiceSpecificException", serviceError.GetExceptionName().c_str());
     ASSERT_STREQ("Error message", serviceError.GetMessage().c_str());
     ASSERT_STREQ("Detailed info", jsonServiceNoResultOperationOutcome.GetError<JsonServiceSpecificException>().GetExceptionInfo().c_str());
-}
\ No newline at end of file
+}
+
+TEST_F(OutcomeTest, CborServiceNoResultOperationOutcomeTestMoveFromCborOutcome)
+{
+    CborServiceErrorMarshaller errorMarshaller;
+    CborServiceNoResultOperationOutcome cborServiceNoResultOperationOutcome(CborOutcome(errorMarshaller.Marshall(*CreateCborErrorHttpResponse())));
+    ASSERT_FALSE(cborServiceNoResultOperationOutcome.IsSuccess());
+    CborServiceError serviceError = cborServiceNoResultOperationOutcome.GetError();
+    ASSERT_EQ(ServiceErrors::SERVICE_SPECIFIC_EXCEPTION, serviceError.GetErrorType());
+    ASSERT_STREQ("ServiceSpecificException", serviceError.GetExceptionName().c_str());
+    ASSERT_STREQ("Error message", serviceError.GetMessage().c_str());
+    ASSERT_STREQ("Detailed info", cborServiceNoResultOperationOutcome.GetError<CborServiceSpecificException>().GetExceptionInfo().c_str());
+    ASSERT_STREQ("Detailed info", cborServiceNoResultOperationOutcome.GetError<CborServiceSpecificException>().GetExceptionInfo().c_str());
+}
diff --git a/tools/code-generation/generator/src/main/java/com/amazonaws/util/awsclientgenerator/transform/C2jModelToGeneratorModelTransformer.java b/tools/code-generation/generator/src/main/java/com/amazonaws/util/awsclientgenerator/transform/C2jModelToGeneratorModelTransformer.java
index 497d716d378..a111b689cc2 100644
--- a/tools/code-generation/generator/src/main/java/com/amazonaws/util/awsclientgenerator/transform/C2jModelToGeneratorModelTransformer.java
+++ b/tools/code-generation/generator/src/main/java/com/amazonaws/util/awsclientgenerator/transform/C2jModelToGeneratorModelTransformer.java
@@ -947,7 +947,8 @@ Error convertError(C2jError c2jError, String operationName) {
                     .build();
             String errorPayloadType = CppViewHelper.computeServicePayloadType(protocols);
             if (errorPayloadType.equals("xml") && referencedShape.isXmlModeledException() ||
-                errorPayloadType.equals("json") && referencedShape.isJsonModeledException()) {
+                errorPayloadType.equals("json") && referencedShape.isJsonModeledException() ||
+                errorPayloadType.equals("smithy-rpc-v2-cbor") && referencedShape.isCborModeledException()) {
                 error.setModeled(true);
             }
 
diff --git a/tools/code-generation/generator/src/main/resources/com/amazonaws/util/awsclientgenerator/velocity/cpp/ServiceErrorsSource.vm b/tools/code-generation/generator/src/main/resources/com/amazonaws/util/awsclientgenerator/velocity/cpp/ServiceErrorsSource.vm
index ad1e6418645..e85dc55c3e5 100644
--- a/tools/code-generation/generator/src/main/resources/com/amazonaws/util/awsclientgenerator/velocity/cpp/ServiceErrorsSource.vm
+++ b/tools/code-generation/generator/src/main/resources/com/amazonaws/util/awsclientgenerator/velocity/cpp/ServiceErrorsSource.vm
@@ -18,6 +18,9 @@
 #set($hasModeledErrors = true)
 #end
 #end
+#if($hasModeledErrors && $payloadType.equals("smithy-rpc-v2-cbor"))
+\#include <aws/core/utils/cbor/CborValue.h>
+#end
 
 using namespace Aws::Client;
 using namespace Aws::Utils;
@@ -42,8 +45,11 @@ template<> ${CppViewHelper.computeExportValue($metadata.classNamePrefix)} ${erro
   assert(this->GetErrorType() == ${metadata.classNamePrefix}Errors::$constName);
 #if($payloadType.equals("xml"))
   return ${error.name}(this->GetXmlPayload().GetRootElement());
-#elseif($$payloadType.equals("json"))
+#elseif($payloadType.equals("json"))
   return ${error.name}(this->GetJsonPayload().View());
+#elseif($payloadType.equals("smithy-rpc-v2-cbor"))
+  Aws::Utils::Cbor::CborValue payload(this->GetCborPayload());
+  return ${error.name}(payload.GetDecoder());
 #end
 }