ECRClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/ecr/ECRPaginationBase.h>
#include <aws/ecr/ECRServiceClientModel.h>
#include <aws/ecr/ECRWaiter.h>
#include <aws/ecr/ECR_EXPORTS.h>
 
namespace Aws {
namespace ECR {
class AWS_ECR_API ECRClient : public Aws::Client::AWSJsonClient,
                              public Aws::Client::ClientWithAsyncTemplateMethods<ECRClient>,
                              public ECRPaginationBase<ECRClient>,
                              public ECRWaiter<ECRClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef ECRClientConfiguration ClientConfigurationType;
  typedef ECREndpointProvider EndpointProviderType;
 
  ECRClient(const Aws::ECR::ECRClientConfiguration& clientConfiguration = Aws::ECR::ECRClientConfiguration(),
            std::shared_ptr<ECREndpointProviderBase> endpointProvider = nullptr);
 
  ECRClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<ECREndpointProviderBase> endpointProvider = nullptr,
            const Aws::ECR::ECRClientConfiguration& clientConfiguration = Aws::ECR::ECRClientConfiguration());
 
  ECRClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            std::shared_ptr<ECREndpointProviderBase> endpointProvider = nullptr,
            const Aws::ECR::ECRClientConfiguration& clientConfiguration = Aws::ECR::ECRClientConfiguration());
 
  /* Legacy constructors due deprecation */
  ECRClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ECRClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ECRClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~ECRClient();
 
  virtual Model::BatchCheckLayerAvailabilityOutcome BatchCheckLayerAvailability(
      const Model::BatchCheckLayerAvailabilityRequest& request) const;
 
  template <typename BatchCheckLayerAvailabilityRequestT = Model::BatchCheckLayerAvailabilityRequest>
  Model::BatchCheckLayerAvailabilityOutcomeCallable BatchCheckLayerAvailabilityCallable(
      const BatchCheckLayerAvailabilityRequestT& request) const {
    return SubmitCallable(&ECRClient::BatchCheckLayerAvailability, request);
  }
 
  template <typename BatchCheckLayerAvailabilityRequestT = Model::BatchCheckLayerAvailabilityRequest>
  void BatchCheckLayerAvailabilityAsync(const BatchCheckLayerAvailabilityRequestT& request,
                                        const BatchCheckLayerAvailabilityResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::BatchCheckLayerAvailability, request, handler, context);
  }
 
  virtual Model::BatchDeleteImageOutcome BatchDeleteImage(const Model::BatchDeleteImageRequest& request) const;
 
  template <typename BatchDeleteImageRequestT = Model::BatchDeleteImageRequest>
  Model::BatchDeleteImageOutcomeCallable BatchDeleteImageCallable(const BatchDeleteImageRequestT& request) const {
    return SubmitCallable(&ECRClient::BatchDeleteImage, request);
  }
 
  template <typename BatchDeleteImageRequestT = Model::BatchDeleteImageRequest>
  void BatchDeleteImageAsync(const BatchDeleteImageRequestT& request, const BatchDeleteImageResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::BatchDeleteImage, request, handler, context);
  }
 
  virtual Model::BatchGetImageOutcome BatchGetImage(const Model::BatchGetImageRequest& request) const;
 
  template <typename BatchGetImageRequestT = Model::BatchGetImageRequest>
  Model::BatchGetImageOutcomeCallable BatchGetImageCallable(const BatchGetImageRequestT& request) const {
    return SubmitCallable(&ECRClient::BatchGetImage, request);
  }
 
  template <typename BatchGetImageRequestT = Model::BatchGetImageRequest>
  void BatchGetImageAsync(const BatchGetImageRequestT& request, const BatchGetImageResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::BatchGetImage, request, handler, context);
  }
 
  virtual Model::BatchGetRepositoryScanningConfigurationOutcome BatchGetRepositoryScanningConfiguration(
      const Model::BatchGetRepositoryScanningConfigurationRequest& request) const;
 
  template <typename BatchGetRepositoryScanningConfigurationRequestT = Model::BatchGetRepositoryScanningConfigurationRequest>
  Model::BatchGetRepositoryScanningConfigurationOutcomeCallable BatchGetRepositoryScanningConfigurationCallable(
      const BatchGetRepositoryScanningConfigurationRequestT& request) const {
    return SubmitCallable(&ECRClient::BatchGetRepositoryScanningConfiguration, request);
  }
 
  template <typename BatchGetRepositoryScanningConfigurationRequestT = Model::BatchGetRepositoryScanningConfigurationRequest>
  void BatchGetRepositoryScanningConfigurationAsync(const BatchGetRepositoryScanningConfigurationRequestT& request,
                                                    const BatchGetRepositoryScanningConfigurationResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::BatchGetRepositoryScanningConfiguration, request, handler, context);
  }
 
  virtual Model::CompleteLayerUploadOutcome CompleteLayerUpload(const Model::CompleteLayerUploadRequest& request) const;
 
  template <typename CompleteLayerUploadRequestT = Model::CompleteLayerUploadRequest>
  Model::CompleteLayerUploadOutcomeCallable CompleteLayerUploadCallable(const CompleteLayerUploadRequestT& request) const {
    return SubmitCallable(&ECRClient::CompleteLayerUpload, request);
  }
 
  template <typename CompleteLayerUploadRequestT = Model::CompleteLayerUploadRequest>
  void CompleteLayerUploadAsync(const CompleteLayerUploadRequestT& request, const CompleteLayerUploadResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::CompleteLayerUpload, request, handler, context);
  }
 
  virtual Model::CreatePullThroughCacheRuleOutcome CreatePullThroughCacheRule(
      const Model::CreatePullThroughCacheRuleRequest& request) const;
 
  template <typename CreatePullThroughCacheRuleRequestT = Model::CreatePullThroughCacheRuleRequest>
  Model::CreatePullThroughCacheRuleOutcomeCallable CreatePullThroughCacheRuleCallable(
      const CreatePullThroughCacheRuleRequestT& request) const {
    return SubmitCallable(&ECRClient::CreatePullThroughCacheRule, request);
  }
 
  template <typename CreatePullThroughCacheRuleRequestT = Model::CreatePullThroughCacheRuleRequest>
  void CreatePullThroughCacheRuleAsync(const CreatePullThroughCacheRuleRequestT& request,
                                       const CreatePullThroughCacheRuleResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::CreatePullThroughCacheRule, request, handler, context);
  }
 
  virtual Model::CreateRepositoryOutcome CreateRepository(const Model::CreateRepositoryRequest& request) const;
 
  template <typename CreateRepositoryRequestT = Model::CreateRepositoryRequest>
  Model::CreateRepositoryOutcomeCallable CreateRepositoryCallable(const CreateRepositoryRequestT& request) const {
    return SubmitCallable(&ECRClient::CreateRepository, request);
  }
 
  template <typename CreateRepositoryRequestT = Model::CreateRepositoryRequest>
  void CreateRepositoryAsync(const CreateRepositoryRequestT& request, const CreateRepositoryResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::CreateRepository, request, handler, context);
  }
 
  virtual Model::CreateRepositoryCreationTemplateOutcome CreateRepositoryCreationTemplate(
      const Model::CreateRepositoryCreationTemplateRequest& request) const;
 
  template <typename CreateRepositoryCreationTemplateRequestT = Model::CreateRepositoryCreationTemplateRequest>
  Model::CreateRepositoryCreationTemplateOutcomeCallable CreateRepositoryCreationTemplateCallable(
      const CreateRepositoryCreationTemplateRequestT& request) const {
    return SubmitCallable(&ECRClient::CreateRepositoryCreationTemplate, request);
  }
 
  template <typename CreateRepositoryCreationTemplateRequestT = Model::CreateRepositoryCreationTemplateRequest>
  void CreateRepositoryCreationTemplateAsync(const CreateRepositoryCreationTemplateRequestT& request,
                                             const CreateRepositoryCreationTemplateResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::CreateRepositoryCreationTemplate, request, handler, context);
  }
 
  virtual Model::DeleteLifecyclePolicyOutcome DeleteLifecyclePolicy(const Model::DeleteLifecyclePolicyRequest& request) const;
 
  template <typename DeleteLifecyclePolicyRequestT = Model::DeleteLifecyclePolicyRequest>
  Model::DeleteLifecyclePolicyOutcomeCallable DeleteLifecyclePolicyCallable(const DeleteLifecyclePolicyRequestT& request) const {
    return SubmitCallable(&ECRClient::DeleteLifecyclePolicy, request);
  }
 
  template <typename DeleteLifecyclePolicyRequestT = Model::DeleteLifecyclePolicyRequest>
  void DeleteLifecyclePolicyAsync(const DeleteLifecyclePolicyRequestT& request, const DeleteLifecyclePolicyResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::DeleteLifecyclePolicy, request, handler, context);
  }
 
  virtual Model::DeletePullThroughCacheRuleOutcome DeletePullThroughCacheRule(
      const Model::DeletePullThroughCacheRuleRequest& request) const;
 
  template <typename DeletePullThroughCacheRuleRequestT = Model::DeletePullThroughCacheRuleRequest>
  Model::DeletePullThroughCacheRuleOutcomeCallable DeletePullThroughCacheRuleCallable(
      const DeletePullThroughCacheRuleRequestT& request) const {
    return SubmitCallable(&ECRClient::DeletePullThroughCacheRule, request);
  }
 
  template <typename DeletePullThroughCacheRuleRequestT = Model::DeletePullThroughCacheRuleRequest>
  void DeletePullThroughCacheRuleAsync(const DeletePullThroughCacheRuleRequestT& request,
                                       const DeletePullThroughCacheRuleResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::DeletePullThroughCacheRule, request, handler, context);
  }
 
  virtual Model::DeleteRegistryPolicyOutcome DeleteRegistryPolicy(const Model::DeleteRegistryPolicyRequest& request = {}) const;
 
  template <typename DeleteRegistryPolicyRequestT = Model::DeleteRegistryPolicyRequest>
  Model::DeleteRegistryPolicyOutcomeCallable DeleteRegistryPolicyCallable(const DeleteRegistryPolicyRequestT& request = {}) const {
    return SubmitCallable(&ECRClient::DeleteRegistryPolicy, request);
  }
 
  template <typename DeleteRegistryPolicyRequestT = Model::DeleteRegistryPolicyRequest>
  void DeleteRegistryPolicyAsync(const DeleteRegistryPolicyResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const DeleteRegistryPolicyRequestT& request = {}) const {
    return SubmitAsync(&ECRClient::DeleteRegistryPolicy, request, handler, context);
  }
 
  virtual Model::DeleteRepositoryOutcome DeleteRepository(const Model::DeleteRepositoryRequest& request) const;
 
  template <typename DeleteRepositoryRequestT = Model::DeleteRepositoryRequest>
  Model::DeleteRepositoryOutcomeCallable DeleteRepositoryCallable(const DeleteRepositoryRequestT& request) const {
    return SubmitCallable(&ECRClient::DeleteRepository, request);
  }
 
  template <typename DeleteRepositoryRequestT = Model::DeleteRepositoryRequest>
  void DeleteRepositoryAsync(const DeleteRepositoryRequestT& request, const DeleteRepositoryResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::DeleteRepository, request, handler, context);
  }
 
  virtual Model::DeleteRepositoryCreationTemplateOutcome DeleteRepositoryCreationTemplate(
      const Model::DeleteRepositoryCreationTemplateRequest& request) const;
 
  template <typename DeleteRepositoryCreationTemplateRequestT = Model::DeleteRepositoryCreationTemplateRequest>
  Model::DeleteRepositoryCreationTemplateOutcomeCallable DeleteRepositoryCreationTemplateCallable(
      const DeleteRepositoryCreationTemplateRequestT& request) const {
    return SubmitCallable(&ECRClient::DeleteRepositoryCreationTemplate, request);
  }
 
  template <typename DeleteRepositoryCreationTemplateRequestT = Model::DeleteRepositoryCreationTemplateRequest>
  void DeleteRepositoryCreationTemplateAsync(const DeleteRepositoryCreationTemplateRequestT& request,
                                             const DeleteRepositoryCreationTemplateResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::DeleteRepositoryCreationTemplate, request, handler, context);
  }
 
  virtual Model::DeleteRepositoryPolicyOutcome DeleteRepositoryPolicy(const Model::DeleteRepositoryPolicyRequest& request) const;
 
  template <typename DeleteRepositoryPolicyRequestT = Model::DeleteRepositoryPolicyRequest>
  Model::DeleteRepositoryPolicyOutcomeCallable DeleteRepositoryPolicyCallable(const DeleteRepositoryPolicyRequestT& request) const {
    return SubmitCallable(&ECRClient::DeleteRepositoryPolicy, request);
  }
 
  template <typename DeleteRepositoryPolicyRequestT = Model::DeleteRepositoryPolicyRequest>
  void DeleteRepositoryPolicyAsync(const DeleteRepositoryPolicyRequestT& request,
                                   const DeleteRepositoryPolicyResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::DeleteRepositoryPolicy, request, handler, context);
  }
 
  virtual Model::DeleteSigningConfigurationOutcome DeleteSigningConfiguration(
      const Model::DeleteSigningConfigurationRequest& request = {}) const;
 
  template <typename DeleteSigningConfigurationRequestT = Model::DeleteSigningConfigurationRequest>
  Model::DeleteSigningConfigurationOutcomeCallable DeleteSigningConfigurationCallable(
      const DeleteSigningConfigurationRequestT& request = {}) const {
    return SubmitCallable(&ECRClient::DeleteSigningConfiguration, request);
  }
 
  template <typename DeleteSigningConfigurationRequestT = Model::DeleteSigningConfigurationRequest>
  void DeleteSigningConfigurationAsync(const DeleteSigningConfigurationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const DeleteSigningConfigurationRequestT& request = {}) const {
    return SubmitAsync(&ECRClient::DeleteSigningConfiguration, request, handler, context);
  }
 
  virtual Model::DeregisterPullTimeUpdateExclusionOutcome DeregisterPullTimeUpdateExclusion(
      const Model::DeregisterPullTimeUpdateExclusionRequest& request) const;
 
  template <typename DeregisterPullTimeUpdateExclusionRequestT = Model::DeregisterPullTimeUpdateExclusionRequest>
  Model::DeregisterPullTimeUpdateExclusionOutcomeCallable DeregisterPullTimeUpdateExclusionCallable(
      const DeregisterPullTimeUpdateExclusionRequestT& request) const {
    return SubmitCallable(&ECRClient::DeregisterPullTimeUpdateExclusion, request);
  }
 
  template <typename DeregisterPullTimeUpdateExclusionRequestT = Model::DeregisterPullTimeUpdateExclusionRequest>
  void DeregisterPullTimeUpdateExclusionAsync(const DeregisterPullTimeUpdateExclusionRequestT& request,
                                              const DeregisterPullTimeUpdateExclusionResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::DeregisterPullTimeUpdateExclusion, request, handler, context);
  }
 
  virtual Model::DescribeImageReplicationStatusOutcome DescribeImageReplicationStatus(
      const Model::DescribeImageReplicationStatusRequest& request) const;
 
  template <typename DescribeImageReplicationStatusRequestT = Model::DescribeImageReplicationStatusRequest>
  Model::DescribeImageReplicationStatusOutcomeCallable DescribeImageReplicationStatusCallable(
      const DescribeImageReplicationStatusRequestT& request) const {
    return SubmitCallable(&ECRClient::DescribeImageReplicationStatus, request);
  }
 
  template <typename DescribeImageReplicationStatusRequestT = Model::DescribeImageReplicationStatusRequest>
  void DescribeImageReplicationStatusAsync(const DescribeImageReplicationStatusRequestT& request,
                                           const DescribeImageReplicationStatusResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::DescribeImageReplicationStatus, request, handler, context);
  }
 
  virtual Model::DescribeImageScanFindingsOutcome DescribeImageScanFindings(const Model::DescribeImageScanFindingsRequest& request) const;
 
  template <typename DescribeImageScanFindingsRequestT = Model::DescribeImageScanFindingsRequest>
  Model::DescribeImageScanFindingsOutcomeCallable DescribeImageScanFindingsCallable(
      const DescribeImageScanFindingsRequestT& request) const {
    return SubmitCallable(&ECRClient::DescribeImageScanFindings, request);
  }
 
  template <typename DescribeImageScanFindingsRequestT = Model::DescribeImageScanFindingsRequest>
  void DescribeImageScanFindingsAsync(const DescribeImageScanFindingsRequestT& request,
                                      const DescribeImageScanFindingsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::DescribeImageScanFindings, request, handler, context);
  }
 
  virtual Model::DescribeImageSigningStatusOutcome DescribeImageSigningStatus(
      const Model::DescribeImageSigningStatusRequest& request) const;
 
  template <typename DescribeImageSigningStatusRequestT = Model::DescribeImageSigningStatusRequest>
  Model::DescribeImageSigningStatusOutcomeCallable DescribeImageSigningStatusCallable(
      const DescribeImageSigningStatusRequestT& request) const {
    return SubmitCallable(&ECRClient::DescribeImageSigningStatus, request);
  }
 
  template <typename DescribeImageSigningStatusRequestT = Model::DescribeImageSigningStatusRequest>
  void DescribeImageSigningStatusAsync(const DescribeImageSigningStatusRequestT& request,
                                       const DescribeImageSigningStatusResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::DescribeImageSigningStatus, request, handler, context);
  }
 
  virtual Model::DescribeImagesOutcome DescribeImages(const Model::DescribeImagesRequest& request) const;
 
  template <typename DescribeImagesRequestT = Model::DescribeImagesRequest>
  Model::DescribeImagesOutcomeCallable DescribeImagesCallable(const DescribeImagesRequestT& request) const {
    return SubmitCallable(&ECRClient::DescribeImages, request);
  }
 
  template <typename DescribeImagesRequestT = Model::DescribeImagesRequest>
  void DescribeImagesAsync(const DescribeImagesRequestT& request, const DescribeImagesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::DescribeImages, request, handler, context);
  }
 
  virtual Model::DescribePullThroughCacheRulesOutcome DescribePullThroughCacheRules(
      const Model::DescribePullThroughCacheRulesRequest& request = {}) const;
 
  template <typename DescribePullThroughCacheRulesRequestT = Model::DescribePullThroughCacheRulesRequest>
  Model::DescribePullThroughCacheRulesOutcomeCallable DescribePullThroughCacheRulesCallable(
      const DescribePullThroughCacheRulesRequestT& request = {}) const {
    return SubmitCallable(&ECRClient::DescribePullThroughCacheRules, request);
  }
 
  template <typename DescribePullThroughCacheRulesRequestT = Model::DescribePullThroughCacheRulesRequest>
  void DescribePullThroughCacheRulesAsync(const DescribePullThroughCacheRulesResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const DescribePullThroughCacheRulesRequestT& request = {}) const {
    return SubmitAsync(&ECRClient::DescribePullThroughCacheRules, request, handler, context);
  }
 
  virtual Model::DescribeRegistryOutcome DescribeRegistry(const Model::DescribeRegistryRequest& request = {}) const;
 
  template <typename DescribeRegistryRequestT = Model::DescribeRegistryRequest>
  Model::DescribeRegistryOutcomeCallable DescribeRegistryCallable(const DescribeRegistryRequestT& request = {}) const {
    return SubmitCallable(&ECRClient::DescribeRegistry, request);
  }
 
  template <typename DescribeRegistryRequestT = Model::DescribeRegistryRequest>
  void DescribeRegistryAsync(const DescribeRegistryResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const DescribeRegistryRequestT& request = {}) const {
    return SubmitAsync(&ECRClient::DescribeRegistry, request, handler, context);
  }
 
  virtual Model::DescribeRepositoriesOutcome DescribeRepositories(const Model::DescribeRepositoriesRequest& request = {}) const;
 
  template <typename DescribeRepositoriesRequestT = Model::DescribeRepositoriesRequest>
  Model::DescribeRepositoriesOutcomeCallable DescribeRepositoriesCallable(const DescribeRepositoriesRequestT& request = {}) const {
    return SubmitCallable(&ECRClient::DescribeRepositories, request);
  }
 
  template <typename DescribeRepositoriesRequestT = Model::DescribeRepositoriesRequest>
  void DescribeRepositoriesAsync(const DescribeRepositoriesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const DescribeRepositoriesRequestT& request = {}) const {
    return SubmitAsync(&ECRClient::DescribeRepositories, request, handler, context);
  }
 
  virtual Model::DescribeRepositoryCreationTemplatesOutcome DescribeRepositoryCreationTemplates(
      const Model::DescribeRepositoryCreationTemplatesRequest& request = {}) const;
 
  template <typename DescribeRepositoryCreationTemplatesRequestT = Model::DescribeRepositoryCreationTemplatesRequest>
  Model::DescribeRepositoryCreationTemplatesOutcomeCallable DescribeRepositoryCreationTemplatesCallable(
      const DescribeRepositoryCreationTemplatesRequestT& request = {}) const {
    return SubmitCallable(&ECRClient::DescribeRepositoryCreationTemplates, request);
  }
 
  template <typename DescribeRepositoryCreationTemplatesRequestT = Model::DescribeRepositoryCreationTemplatesRequest>
  void DescribeRepositoryCreationTemplatesAsync(const DescribeRepositoryCreationTemplatesResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                const DescribeRepositoryCreationTemplatesRequestT& request = {}) const {
    return SubmitAsync(&ECRClient::DescribeRepositoryCreationTemplates, request, handler, context);
  }
 
  virtual Model::GetAccountSettingOutcome GetAccountSetting(const Model::GetAccountSettingRequest& request) const;
 
  template <typename GetAccountSettingRequestT = Model::GetAccountSettingRequest>
  Model::GetAccountSettingOutcomeCallable GetAccountSettingCallable(const GetAccountSettingRequestT& request) const {
    return SubmitCallable(&ECRClient::GetAccountSetting, request);
  }
 
  template <typename GetAccountSettingRequestT = Model::GetAccountSettingRequest>
  void GetAccountSettingAsync(const GetAccountSettingRequestT& request, const GetAccountSettingResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::GetAccountSetting, request, handler, context);
  }
 
  virtual Model::GetAuthorizationTokenOutcome GetAuthorizationToken(const Model::GetAuthorizationTokenRequest& request = {}) const;
 
  template <typename GetAuthorizationTokenRequestT = Model::GetAuthorizationTokenRequest>
  Model::GetAuthorizationTokenOutcomeCallable GetAuthorizationTokenCallable(const GetAuthorizationTokenRequestT& request = {}) const {
    return SubmitCallable(&ECRClient::GetAuthorizationToken, request);
  }
 
  template <typename GetAuthorizationTokenRequestT = Model::GetAuthorizationTokenRequest>
  void GetAuthorizationTokenAsync(const GetAuthorizationTokenResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const GetAuthorizationTokenRequestT& request = {}) const {
    return SubmitAsync(&ECRClient::GetAuthorizationToken, request, handler, context);
  }
 
  virtual Model::GetDownloadUrlForLayerOutcome GetDownloadUrlForLayer(const Model::GetDownloadUrlForLayerRequest& request) const;
 
  template <typename GetDownloadUrlForLayerRequestT = Model::GetDownloadUrlForLayerRequest>
  Model::GetDownloadUrlForLayerOutcomeCallable GetDownloadUrlForLayerCallable(const GetDownloadUrlForLayerRequestT& request) const {
    return SubmitCallable(&ECRClient::GetDownloadUrlForLayer, request);
  }
 
  template <typename GetDownloadUrlForLayerRequestT = Model::GetDownloadUrlForLayerRequest>
  void GetDownloadUrlForLayerAsync(const GetDownloadUrlForLayerRequestT& request,
                                   const GetDownloadUrlForLayerResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::GetDownloadUrlForLayer, request, handler, context);
  }
 
  virtual Model::GetLifecyclePolicyOutcome GetLifecyclePolicy(const Model::GetLifecyclePolicyRequest& request) const;
 
  template <typename GetLifecyclePolicyRequestT = Model::GetLifecyclePolicyRequest>
  Model::GetLifecyclePolicyOutcomeCallable GetLifecyclePolicyCallable(const GetLifecyclePolicyRequestT& request) const {
    return SubmitCallable(&ECRClient::GetLifecyclePolicy, request);
  }
 
  template <typename GetLifecyclePolicyRequestT = Model::GetLifecyclePolicyRequest>
  void GetLifecyclePolicyAsync(const GetLifecyclePolicyRequestT& request, const GetLifecyclePolicyResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::GetLifecyclePolicy, request, handler, context);
  }
 
  virtual Model::GetLifecyclePolicyPreviewOutcome GetLifecyclePolicyPreview(const Model::GetLifecyclePolicyPreviewRequest& request) const;
 
  template <typename GetLifecyclePolicyPreviewRequestT = Model::GetLifecyclePolicyPreviewRequest>
  Model::GetLifecyclePolicyPreviewOutcomeCallable GetLifecyclePolicyPreviewCallable(
      const GetLifecyclePolicyPreviewRequestT& request) const {
    return SubmitCallable(&ECRClient::GetLifecyclePolicyPreview, request);
  }
 
  template <typename GetLifecyclePolicyPreviewRequestT = Model::GetLifecyclePolicyPreviewRequest>
  void GetLifecyclePolicyPreviewAsync(const GetLifecyclePolicyPreviewRequestT& request,
                                      const GetLifecyclePolicyPreviewResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::GetLifecyclePolicyPreview, request, handler, context);
  }
 
  virtual Model::GetRegistryPolicyOutcome GetRegistryPolicy(const Model::GetRegistryPolicyRequest& request = {}) const;
 
  template <typename GetRegistryPolicyRequestT = Model::GetRegistryPolicyRequest>
  Model::GetRegistryPolicyOutcomeCallable GetRegistryPolicyCallable(const GetRegistryPolicyRequestT& request = {}) const {
    return SubmitCallable(&ECRClient::GetRegistryPolicy, request);
  }
 
  template <typename GetRegistryPolicyRequestT = Model::GetRegistryPolicyRequest>
  void GetRegistryPolicyAsync(const GetRegistryPolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const GetRegistryPolicyRequestT& request = {}) const {
    return SubmitAsync(&ECRClient::GetRegistryPolicy, request, handler, context);
  }
 
  virtual Model::GetRegistryScanningConfigurationOutcome GetRegistryScanningConfiguration(
      const Model::GetRegistryScanningConfigurationRequest& request = {}) const;
 
  template <typename GetRegistryScanningConfigurationRequestT = Model::GetRegistryScanningConfigurationRequest>
  Model::GetRegistryScanningConfigurationOutcomeCallable GetRegistryScanningConfigurationCallable(
      const GetRegistryScanningConfigurationRequestT& request = {}) const {
    return SubmitCallable(&ECRClient::GetRegistryScanningConfiguration, request);
  }
 
  template <typename GetRegistryScanningConfigurationRequestT = Model::GetRegistryScanningConfigurationRequest>
  void GetRegistryScanningConfigurationAsync(const GetRegistryScanningConfigurationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                             const GetRegistryScanningConfigurationRequestT& request = {}) const {
    return SubmitAsync(&ECRClient::GetRegistryScanningConfiguration, request, handler, context);
  }
 
  virtual Model::GetRepositoryPolicyOutcome GetRepositoryPolicy(const Model::GetRepositoryPolicyRequest& request) const;
 
  template <typename GetRepositoryPolicyRequestT = Model::GetRepositoryPolicyRequest>
  Model::GetRepositoryPolicyOutcomeCallable GetRepositoryPolicyCallable(const GetRepositoryPolicyRequestT& request) const {
    return SubmitCallable(&ECRClient::GetRepositoryPolicy, request);
  }
 
  template <typename GetRepositoryPolicyRequestT = Model::GetRepositoryPolicyRequest>
  void GetRepositoryPolicyAsync(const GetRepositoryPolicyRequestT& request, const GetRepositoryPolicyResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::GetRepositoryPolicy, request, handler, context);
  }
 
  virtual Model::GetSigningConfigurationOutcome GetSigningConfiguration(const Model::GetSigningConfigurationRequest& request = {}) const;
 
  template <typename GetSigningConfigurationRequestT = Model::GetSigningConfigurationRequest>
  Model::GetSigningConfigurationOutcomeCallable GetSigningConfigurationCallable(const GetSigningConfigurationRequestT& request = {}) const {
    return SubmitCallable(&ECRClient::GetSigningConfiguration, request);
  }
 
  template <typename GetSigningConfigurationRequestT = Model::GetSigningConfigurationRequest>
  void GetSigningConfigurationAsync(const GetSigningConfigurationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const GetSigningConfigurationRequestT& request = {}) const {
    return SubmitAsync(&ECRClient::GetSigningConfiguration, request, handler, context);
  }
 
  virtual Model::InitiateLayerUploadOutcome InitiateLayerUpload(const Model::InitiateLayerUploadRequest& request) const;
 
  template <typename InitiateLayerUploadRequestT = Model::InitiateLayerUploadRequest>
  Model::InitiateLayerUploadOutcomeCallable InitiateLayerUploadCallable(const InitiateLayerUploadRequestT& request) const {
    return SubmitCallable(&ECRClient::InitiateLayerUpload, request);
  }
 
  template <typename InitiateLayerUploadRequestT = Model::InitiateLayerUploadRequest>
  void InitiateLayerUploadAsync(const InitiateLayerUploadRequestT& request, const InitiateLayerUploadResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::InitiateLayerUpload, request, handler, context);
  }
 
  virtual Model::ListImageReferrersOutcome ListImageReferrers(const Model::ListImageReferrersRequest& request) const;
 
  template <typename ListImageReferrersRequestT = Model::ListImageReferrersRequest>
  Model::ListImageReferrersOutcomeCallable ListImageReferrersCallable(const ListImageReferrersRequestT& request) const {
    return SubmitCallable(&ECRClient::ListImageReferrers, request);
  }
 
  template <typename ListImageReferrersRequestT = Model::ListImageReferrersRequest>
  void ListImageReferrersAsync(const ListImageReferrersRequestT& request, const ListImageReferrersResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::ListImageReferrers, request, handler, context);
  }
 
  virtual Model::ListImagesOutcome ListImages(const Model::ListImagesRequest& request) const;
 
  template <typename ListImagesRequestT = Model::ListImagesRequest>
  Model::ListImagesOutcomeCallable ListImagesCallable(const ListImagesRequestT& request) const {
    return SubmitCallable(&ECRClient::ListImages, request);
  }
 
  template <typename ListImagesRequestT = Model::ListImagesRequest>
  void ListImagesAsync(const ListImagesRequestT& request, const ListImagesResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::ListImages, request, handler, context);
  }
 
  virtual Model::ListPullTimeUpdateExclusionsOutcome ListPullTimeUpdateExclusions(
      const Model::ListPullTimeUpdateExclusionsRequest& request = {}) const;
 
  template <typename ListPullTimeUpdateExclusionsRequestT = Model::ListPullTimeUpdateExclusionsRequest>
  Model::ListPullTimeUpdateExclusionsOutcomeCallable ListPullTimeUpdateExclusionsCallable(
      const ListPullTimeUpdateExclusionsRequestT& request = {}) const {
    return SubmitCallable(&ECRClient::ListPullTimeUpdateExclusions, request);
  }
 
  template <typename ListPullTimeUpdateExclusionsRequestT = Model::ListPullTimeUpdateExclusionsRequest>
  void ListPullTimeUpdateExclusionsAsync(const ListPullTimeUpdateExclusionsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const ListPullTimeUpdateExclusionsRequestT& request = {}) const {
    return SubmitAsync(&ECRClient::ListPullTimeUpdateExclusions, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&ECRClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::PutAccountSettingOutcome PutAccountSetting(const Model::PutAccountSettingRequest& request) const;
 
  template <typename PutAccountSettingRequestT = Model::PutAccountSettingRequest>
  Model::PutAccountSettingOutcomeCallable PutAccountSettingCallable(const PutAccountSettingRequestT& request) const {
    return SubmitCallable(&ECRClient::PutAccountSetting, request);
  }
 
  template <typename PutAccountSettingRequestT = Model::PutAccountSettingRequest>
  void PutAccountSettingAsync(const PutAccountSettingRequestT& request, const PutAccountSettingResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::PutAccountSetting, request, handler, context);
  }
 
  virtual Model::PutImageOutcome PutImage(const Model::PutImageRequest& request) const;
 
  template <typename PutImageRequestT = Model::PutImageRequest>
  Model::PutImageOutcomeCallable PutImageCallable(const PutImageRequestT& request) const {
    return SubmitCallable(&ECRClient::PutImage, request);
  }
 
  template <typename PutImageRequestT = Model::PutImageRequest>
  void PutImageAsync(const PutImageRequestT& request, const PutImageResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::PutImage, request, handler, context);
  }
 
  virtual Model::PutImageScanningConfigurationOutcome PutImageScanningConfiguration(
      const Model::PutImageScanningConfigurationRequest& request) const;
 
  template <typename PutImageScanningConfigurationRequestT = Model::PutImageScanningConfigurationRequest>
  Model::PutImageScanningConfigurationOutcomeCallable PutImageScanningConfigurationCallable(
      const PutImageScanningConfigurationRequestT& request) const {
    return SubmitCallable(&ECRClient::PutImageScanningConfiguration, request);
  }
 
  template <typename PutImageScanningConfigurationRequestT = Model::PutImageScanningConfigurationRequest>
  void PutImageScanningConfigurationAsync(const PutImageScanningConfigurationRequestT& request,
                                          const PutImageScanningConfigurationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::PutImageScanningConfiguration, request, handler, context);
  }
 
  virtual Model::PutImageTagMutabilityOutcome PutImageTagMutability(const Model::PutImageTagMutabilityRequest& request) const;
 
  template <typename PutImageTagMutabilityRequestT = Model::PutImageTagMutabilityRequest>
  Model::PutImageTagMutabilityOutcomeCallable PutImageTagMutabilityCallable(const PutImageTagMutabilityRequestT& request) const {
    return SubmitCallable(&ECRClient::PutImageTagMutability, request);
  }
 
  template <typename PutImageTagMutabilityRequestT = Model::PutImageTagMutabilityRequest>
  void PutImageTagMutabilityAsync(const PutImageTagMutabilityRequestT& request, const PutImageTagMutabilityResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::PutImageTagMutability, request, handler, context);
  }
 
  virtual Model::PutLifecyclePolicyOutcome PutLifecyclePolicy(const Model::PutLifecyclePolicyRequest& request) const;
 
  template <typename PutLifecyclePolicyRequestT = Model::PutLifecyclePolicyRequest>
  Model::PutLifecyclePolicyOutcomeCallable PutLifecyclePolicyCallable(const PutLifecyclePolicyRequestT& request) const {
    return SubmitCallable(&ECRClient::PutLifecyclePolicy, request);
  }
 
  template <typename PutLifecyclePolicyRequestT = Model::PutLifecyclePolicyRequest>
  void PutLifecyclePolicyAsync(const PutLifecyclePolicyRequestT& request, const PutLifecyclePolicyResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::PutLifecyclePolicy, request, handler, context);
  }
 
  virtual Model::PutRegistryPolicyOutcome PutRegistryPolicy(const Model::PutRegistryPolicyRequest& request) const;
 
  template <typename PutRegistryPolicyRequestT = Model::PutRegistryPolicyRequest>
  Model::PutRegistryPolicyOutcomeCallable PutRegistryPolicyCallable(const PutRegistryPolicyRequestT& request) const {
    return SubmitCallable(&ECRClient::PutRegistryPolicy, request);
  }
 
  template <typename PutRegistryPolicyRequestT = Model::PutRegistryPolicyRequest>
  void PutRegistryPolicyAsync(const PutRegistryPolicyRequestT& request, const PutRegistryPolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::PutRegistryPolicy, request, handler, context);
  }
 
  virtual Model::PutRegistryScanningConfigurationOutcome PutRegistryScanningConfiguration(
      const Model::PutRegistryScanningConfigurationRequest& request = {}) const;
 
  template <typename PutRegistryScanningConfigurationRequestT = Model::PutRegistryScanningConfigurationRequest>
  Model::PutRegistryScanningConfigurationOutcomeCallable PutRegistryScanningConfigurationCallable(
      const PutRegistryScanningConfigurationRequestT& request = {}) const {
    return SubmitCallable(&ECRClient::PutRegistryScanningConfiguration, request);
  }
 
  template <typename PutRegistryScanningConfigurationRequestT = Model::PutRegistryScanningConfigurationRequest>
  void PutRegistryScanningConfigurationAsync(const PutRegistryScanningConfigurationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                             const PutRegistryScanningConfigurationRequestT& request = {}) const {
    return SubmitAsync(&ECRClient::PutRegistryScanningConfiguration, request, handler, context);
  }
 
  virtual Model::PutReplicationConfigurationOutcome PutReplicationConfiguration(
      const Model::PutReplicationConfigurationRequest& request) const;
 
  template <typename PutReplicationConfigurationRequestT = Model::PutReplicationConfigurationRequest>
  Model::PutReplicationConfigurationOutcomeCallable PutReplicationConfigurationCallable(
      const PutReplicationConfigurationRequestT& request) const {
    return SubmitCallable(&ECRClient::PutReplicationConfiguration, request);
  }
 
  template <typename PutReplicationConfigurationRequestT = Model::PutReplicationConfigurationRequest>
  void PutReplicationConfigurationAsync(const PutReplicationConfigurationRequestT& request,
                                        const PutReplicationConfigurationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::PutReplicationConfiguration, request, handler, context);
  }
 
  virtual Model::PutSigningConfigurationOutcome PutSigningConfiguration(const Model::PutSigningConfigurationRequest& request) const;
 
  template <typename PutSigningConfigurationRequestT = Model::PutSigningConfigurationRequest>
  Model::PutSigningConfigurationOutcomeCallable PutSigningConfigurationCallable(const PutSigningConfigurationRequestT& request) const {
    return SubmitCallable(&ECRClient::PutSigningConfiguration, request);
  }
 
  template <typename PutSigningConfigurationRequestT = Model::PutSigningConfigurationRequest>
  void PutSigningConfigurationAsync(const PutSigningConfigurationRequestT& request,
                                    const PutSigningConfigurationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::PutSigningConfiguration, request, handler, context);
  }
 
  virtual Model::RegisterPullTimeUpdateExclusionOutcome RegisterPullTimeUpdateExclusion(
      const Model::RegisterPullTimeUpdateExclusionRequest& request) const;
 
  template <typename RegisterPullTimeUpdateExclusionRequestT = Model::RegisterPullTimeUpdateExclusionRequest>
  Model::RegisterPullTimeUpdateExclusionOutcomeCallable RegisterPullTimeUpdateExclusionCallable(
      const RegisterPullTimeUpdateExclusionRequestT& request) const {
    return SubmitCallable(&ECRClient::RegisterPullTimeUpdateExclusion, request);
  }
 
  template <typename RegisterPullTimeUpdateExclusionRequestT = Model::RegisterPullTimeUpdateExclusionRequest>
  void RegisterPullTimeUpdateExclusionAsync(const RegisterPullTimeUpdateExclusionRequestT& request,
                                            const RegisterPullTimeUpdateExclusionResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::RegisterPullTimeUpdateExclusion, request, handler, context);
  }
 
  virtual Model::SetRepositoryPolicyOutcome SetRepositoryPolicy(const Model::SetRepositoryPolicyRequest& request) const;
 
  template <typename SetRepositoryPolicyRequestT = Model::SetRepositoryPolicyRequest>
  Model::SetRepositoryPolicyOutcomeCallable SetRepositoryPolicyCallable(const SetRepositoryPolicyRequestT& request) const {
    return SubmitCallable(&ECRClient::SetRepositoryPolicy, request);
  }
 
  template <typename SetRepositoryPolicyRequestT = Model::SetRepositoryPolicyRequest>
  void SetRepositoryPolicyAsync(const SetRepositoryPolicyRequestT& request, const SetRepositoryPolicyResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::SetRepositoryPolicy, request, handler, context);
  }
 
  virtual Model::StartImageScanOutcome StartImageScan(const Model::StartImageScanRequest& request) const;
 
  template <typename StartImageScanRequestT = Model::StartImageScanRequest>
  Model::StartImageScanOutcomeCallable StartImageScanCallable(const StartImageScanRequestT& request) const {
    return SubmitCallable(&ECRClient::StartImageScan, request);
  }
 
  template <typename StartImageScanRequestT = Model::StartImageScanRequest>
  void StartImageScanAsync(const StartImageScanRequestT& request, const StartImageScanResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::StartImageScan, request, handler, context);
  }
 
  virtual Model::StartLifecyclePolicyPreviewOutcome StartLifecyclePolicyPreview(
      const Model::StartLifecyclePolicyPreviewRequest& request) const;
 
  template <typename StartLifecyclePolicyPreviewRequestT = Model::StartLifecyclePolicyPreviewRequest>
  Model::StartLifecyclePolicyPreviewOutcomeCallable StartLifecyclePolicyPreviewCallable(
      const StartLifecyclePolicyPreviewRequestT& request) const {
    return SubmitCallable(&ECRClient::StartLifecyclePolicyPreview, request);
  }
 
  template <typename StartLifecyclePolicyPreviewRequestT = Model::StartLifecyclePolicyPreviewRequest>
  void StartLifecyclePolicyPreviewAsync(const StartLifecyclePolicyPreviewRequestT& request,
                                        const StartLifecyclePolicyPreviewResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::StartLifecyclePolicyPreview, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&ECRClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&ECRClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateImageStorageClassOutcome UpdateImageStorageClass(const Model::UpdateImageStorageClassRequest& request) const;
 
  template <typename UpdateImageStorageClassRequestT = Model::UpdateImageStorageClassRequest>
  Model::UpdateImageStorageClassOutcomeCallable UpdateImageStorageClassCallable(const UpdateImageStorageClassRequestT& request) const {
    return SubmitCallable(&ECRClient::UpdateImageStorageClass, request);
  }
 
  template <typename UpdateImageStorageClassRequestT = Model::UpdateImageStorageClassRequest>
  void UpdateImageStorageClassAsync(const UpdateImageStorageClassRequestT& request,
                                    const UpdateImageStorageClassResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::UpdateImageStorageClass, request, handler, context);
  }
 
  virtual Model::UpdatePullThroughCacheRuleOutcome UpdatePullThroughCacheRule(
      const Model::UpdatePullThroughCacheRuleRequest& request) const;
 
  template <typename UpdatePullThroughCacheRuleRequestT = Model::UpdatePullThroughCacheRuleRequest>
  Model::UpdatePullThroughCacheRuleOutcomeCallable UpdatePullThroughCacheRuleCallable(
      const UpdatePullThroughCacheRuleRequestT& request) const {
    return SubmitCallable(&ECRClient::UpdatePullThroughCacheRule, request);
  }
 
  template <typename UpdatePullThroughCacheRuleRequestT = Model::UpdatePullThroughCacheRuleRequest>
  void UpdatePullThroughCacheRuleAsync(const UpdatePullThroughCacheRuleRequestT& request,
                                       const UpdatePullThroughCacheRuleResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::UpdatePullThroughCacheRule, request, handler, context);
  }
 
  virtual Model::UpdateRepositoryCreationTemplateOutcome UpdateRepositoryCreationTemplate(
      const Model::UpdateRepositoryCreationTemplateRequest& request) const;
 
  template <typename UpdateRepositoryCreationTemplateRequestT = Model::UpdateRepositoryCreationTemplateRequest>
  Model::UpdateRepositoryCreationTemplateOutcomeCallable UpdateRepositoryCreationTemplateCallable(
      const UpdateRepositoryCreationTemplateRequestT& request) const {
    return SubmitCallable(&ECRClient::UpdateRepositoryCreationTemplate, request);
  }
 
  template <typename UpdateRepositoryCreationTemplateRequestT = Model::UpdateRepositoryCreationTemplateRequest>
  void UpdateRepositoryCreationTemplateAsync(const UpdateRepositoryCreationTemplateRequestT& request,
                                             const UpdateRepositoryCreationTemplateResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::UpdateRepositoryCreationTemplate, request, handler, context);
  }
 
  virtual Model::UploadLayerPartOutcome UploadLayerPart(const Model::UploadLayerPartRequest& request) const;
 
  template <typename UploadLayerPartRequestT = Model::UploadLayerPartRequest>
  Model::UploadLayerPartOutcomeCallable UploadLayerPartCallable(const UploadLayerPartRequestT& request) const {
    return SubmitCallable(&ECRClient::UploadLayerPart, request);
  }
 
  template <typename UploadLayerPartRequestT = Model::UploadLayerPartRequest>
  void UploadLayerPartAsync(const UploadLayerPartRequestT& request, const UploadLayerPartResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::UploadLayerPart, request, handler, context);
  }
 
  virtual Model::ValidatePullThroughCacheRuleOutcome ValidatePullThroughCacheRule(
      const Model::ValidatePullThroughCacheRuleRequest& request) const;
 
  template <typename ValidatePullThroughCacheRuleRequestT = Model::ValidatePullThroughCacheRuleRequest>
  Model::ValidatePullThroughCacheRuleOutcomeCallable ValidatePullThroughCacheRuleCallable(
      const ValidatePullThroughCacheRuleRequestT& request) const {
    return SubmitCallable(&ECRClient::ValidatePullThroughCacheRule, request);
  }
 
  template <typename ValidatePullThroughCacheRuleRequestT = Model::ValidatePullThroughCacheRuleRequest>
  void ValidatePullThroughCacheRuleAsync(const ValidatePullThroughCacheRuleRequestT& request,
                                         const ValidatePullThroughCacheRuleResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ECRClient::ValidatePullThroughCacheRule, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ECREndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ECRClient>;
  void init(const ECRClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, ECRError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  ECRClientConfiguration m_clientConfiguration;
  std::shared_ptr<ECREndpointProviderBase> m_endpointProvider;
};
 
}  // namespace ECR
}  // namespace Aws