ECRClient.h

 
#pragma once
#include <aws/ecr/ECR_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/ecr/ECRServiceClientModel.h>
 
namespace Aws
{
namespace ECR
{
  class AWS_ECR_API ECRClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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::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::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::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::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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<ECREndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<ECRClient>;
      void init(const ECRClientConfiguration& clientConfiguration);
 
      ECRClientConfiguration m_clientConfiguration;
      std::shared_ptr<ECREndpointProviderBase> m_endpointProvider;
  };
 
} // namespace ECR
} // namespace Aws