CloudFrontClient.h

 
#pragma once
#include <aws/cloudfront/CloudFrontPaginationBase.h>
#include <aws/cloudfront/CloudFrontServiceClientModel.h>
#include <aws/cloudfront/CloudFrontWaiter.h>
#include <aws/cloudfront/CloudFront_EXPORTS.h>
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/xml/XmlSerializer.h>
 
namespace Aws {
namespace CloudFront {
class AWS_CLOUDFRONT_API CloudFrontClient : public Aws::Client::AWSXMLClient,
                                            public Aws::Client::ClientWithAsyncTemplateMethods<CloudFrontClient>,
                                            public CloudFrontPaginationBase<CloudFrontClient>,
                                            public CloudFrontWaiter<CloudFrontClient> {
 public:
  typedef Aws::Client::AWSXMLClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef CloudFrontClientConfiguration ClientConfigurationType;
  typedef CloudFrontEndpointProvider EndpointProviderType;
 
  CloudFrontClient(
      const Aws::CloudFront::CloudFrontClientConfiguration& clientConfiguration = Aws::CloudFront::CloudFrontClientConfiguration(),
      std::shared_ptr<CloudFrontEndpointProviderBase> endpointProvider = nullptr);
 
  CloudFrontClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<CloudFrontEndpointProviderBase> endpointProvider = nullptr,
      const Aws::CloudFront::CloudFrontClientConfiguration& clientConfiguration = Aws::CloudFront::CloudFrontClientConfiguration());
 
  CloudFrontClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<CloudFrontEndpointProviderBase> endpointProvider = nullptr,
      const Aws::CloudFront::CloudFrontClientConfiguration& clientConfiguration = Aws::CloudFront::CloudFrontClientConfiguration());
 
  /* Legacy constructors due deprecation */
  CloudFrontClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CloudFrontClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CloudFrontClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                   const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~CloudFrontClient();
 
  virtual Model::AssociateAlias2020_05_31Outcome AssociateAlias2020_05_31(const Model::AssociateAlias2020_05_31Request& request) const;
 
  template <typename AssociateAlias2020_05_31RequestT = Model::AssociateAlias2020_05_31Request>
  Model::AssociateAlias2020_05_31OutcomeCallable AssociateAlias2020_05_31Callable(const AssociateAlias2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::AssociateAlias2020_05_31, request);
  }
 
  template <typename AssociateAlias2020_05_31RequestT = Model::AssociateAlias2020_05_31Request>
  void AssociateAlias2020_05_31Async(const AssociateAlias2020_05_31RequestT& request,
                                     const AssociateAlias2020_05_31ResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::AssociateAlias2020_05_31, request, handler, context);
  }
 
  virtual Model::AssociateDistributionTenantWebACL2020_05_31Outcome AssociateDistributionTenantWebACL2020_05_31(
      const Model::AssociateDistributionTenantWebACL2020_05_31Request& request) const;
 
  template <typename AssociateDistributionTenantWebACL2020_05_31RequestT = Model::AssociateDistributionTenantWebACL2020_05_31Request>
  Model::AssociateDistributionTenantWebACL2020_05_31OutcomeCallable AssociateDistributionTenantWebACL2020_05_31Callable(
      const AssociateDistributionTenantWebACL2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::AssociateDistributionTenantWebACL2020_05_31, request);
  }
 
  template <typename AssociateDistributionTenantWebACL2020_05_31RequestT = Model::AssociateDistributionTenantWebACL2020_05_31Request>
  void AssociateDistributionTenantWebACL2020_05_31Async(
      const AssociateDistributionTenantWebACL2020_05_31RequestT& request,
      const AssociateDistributionTenantWebACL2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::AssociateDistributionTenantWebACL2020_05_31, request, handler, context);
  }
 
  virtual Model::AssociateDistributionWebACL2020_05_31Outcome AssociateDistributionWebACL2020_05_31(
      const Model::AssociateDistributionWebACL2020_05_31Request& request) const;
 
  template <typename AssociateDistributionWebACL2020_05_31RequestT = Model::AssociateDistributionWebACL2020_05_31Request>
  Model::AssociateDistributionWebACL2020_05_31OutcomeCallable AssociateDistributionWebACL2020_05_31Callable(
      const AssociateDistributionWebACL2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::AssociateDistributionWebACL2020_05_31, request);
  }
 
  template <typename AssociateDistributionWebACL2020_05_31RequestT = Model::AssociateDistributionWebACL2020_05_31Request>
  void AssociateDistributionWebACL2020_05_31Async(const AssociateDistributionWebACL2020_05_31RequestT& request,
                                                  const AssociateDistributionWebACL2020_05_31ResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::AssociateDistributionWebACL2020_05_31, request, handler, context);
  }
 
  virtual Model::CopyDistribution2020_05_31Outcome CopyDistribution2020_05_31(
      const Model::CopyDistribution2020_05_31Request& request) const;
 
  template <typename CopyDistribution2020_05_31RequestT = Model::CopyDistribution2020_05_31Request>
  Model::CopyDistribution2020_05_31OutcomeCallable CopyDistribution2020_05_31Callable(
      const CopyDistribution2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CopyDistribution2020_05_31, request);
  }
 
  template <typename CopyDistribution2020_05_31RequestT = Model::CopyDistribution2020_05_31Request>
  void CopyDistribution2020_05_31Async(const CopyDistribution2020_05_31RequestT& request,
                                       const CopyDistribution2020_05_31ResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CopyDistribution2020_05_31, request, handler, context);
  }
 
  virtual Model::CreateAnycastIpList2020_05_31Outcome CreateAnycastIpList2020_05_31(
      const Model::CreateAnycastIpList2020_05_31Request& request) const;
 
  template <typename CreateAnycastIpList2020_05_31RequestT = Model::CreateAnycastIpList2020_05_31Request>
  Model::CreateAnycastIpList2020_05_31OutcomeCallable CreateAnycastIpList2020_05_31Callable(
      const CreateAnycastIpList2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CreateAnycastIpList2020_05_31, request);
  }
 
  template <typename CreateAnycastIpList2020_05_31RequestT = Model::CreateAnycastIpList2020_05_31Request>
  void CreateAnycastIpList2020_05_31Async(const CreateAnycastIpList2020_05_31RequestT& request,
                                          const CreateAnycastIpList2020_05_31ResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CreateAnycastIpList2020_05_31, request, handler, context);
  }
 
  virtual Model::CreateCachePolicy2020_05_31Outcome CreateCachePolicy2020_05_31(
      const Model::CreateCachePolicy2020_05_31Request& request) const;
 
  template <typename CreateCachePolicy2020_05_31RequestT = Model::CreateCachePolicy2020_05_31Request>
  Model::CreateCachePolicy2020_05_31OutcomeCallable CreateCachePolicy2020_05_31Callable(
      const CreateCachePolicy2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CreateCachePolicy2020_05_31, request);
  }
 
  template <typename CreateCachePolicy2020_05_31RequestT = Model::CreateCachePolicy2020_05_31Request>
  void CreateCachePolicy2020_05_31Async(const CreateCachePolicy2020_05_31RequestT& request,
                                        const CreateCachePolicy2020_05_31ResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CreateCachePolicy2020_05_31, request, handler, context);
  }
 
  virtual Model::CreateCloudFrontOriginAccessIdentity2020_05_31Outcome CreateCloudFrontOriginAccessIdentity2020_05_31(
      const Model::CreateCloudFrontOriginAccessIdentity2020_05_31Request& request) const;
 
  template <typename CreateCloudFrontOriginAccessIdentity2020_05_31RequestT = Model::CreateCloudFrontOriginAccessIdentity2020_05_31Request>
  Model::CreateCloudFrontOriginAccessIdentity2020_05_31OutcomeCallable CreateCloudFrontOriginAccessIdentity2020_05_31Callable(
      const CreateCloudFrontOriginAccessIdentity2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CreateCloudFrontOriginAccessIdentity2020_05_31, request);
  }
 
  template <typename CreateCloudFrontOriginAccessIdentity2020_05_31RequestT = Model::CreateCloudFrontOriginAccessIdentity2020_05_31Request>
  void CreateCloudFrontOriginAccessIdentity2020_05_31Async(
      const CreateCloudFrontOriginAccessIdentity2020_05_31RequestT& request,
      const CreateCloudFrontOriginAccessIdentity2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CreateCloudFrontOriginAccessIdentity2020_05_31, request, handler, context);
  }
 
  virtual Model::CreateConnectionFunction2020_05_31Outcome CreateConnectionFunction2020_05_31(
      const Model::CreateConnectionFunction2020_05_31Request& request) const;
 
  template <typename CreateConnectionFunction2020_05_31RequestT = Model::CreateConnectionFunction2020_05_31Request>
  Model::CreateConnectionFunction2020_05_31OutcomeCallable CreateConnectionFunction2020_05_31Callable(
      const CreateConnectionFunction2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CreateConnectionFunction2020_05_31, request);
  }
 
  template <typename CreateConnectionFunction2020_05_31RequestT = Model::CreateConnectionFunction2020_05_31Request>
  void CreateConnectionFunction2020_05_31Async(const CreateConnectionFunction2020_05_31RequestT& request,
                                               const CreateConnectionFunction2020_05_31ResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CreateConnectionFunction2020_05_31, request, handler, context);
  }
 
  virtual Model::CreateConnectionGroup2020_05_31Outcome CreateConnectionGroup2020_05_31(
      const Model::CreateConnectionGroup2020_05_31Request& request) const;
 
  template <typename CreateConnectionGroup2020_05_31RequestT = Model::CreateConnectionGroup2020_05_31Request>
  Model::CreateConnectionGroup2020_05_31OutcomeCallable CreateConnectionGroup2020_05_31Callable(
      const CreateConnectionGroup2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CreateConnectionGroup2020_05_31, request);
  }
 
  template <typename CreateConnectionGroup2020_05_31RequestT = Model::CreateConnectionGroup2020_05_31Request>
  void CreateConnectionGroup2020_05_31Async(const CreateConnectionGroup2020_05_31RequestT& request,
                                            const CreateConnectionGroup2020_05_31ResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CreateConnectionGroup2020_05_31, request, handler, context);
  }
 
  virtual Model::CreateContinuousDeploymentPolicy2020_05_31Outcome CreateContinuousDeploymentPolicy2020_05_31(
      const Model::CreateContinuousDeploymentPolicy2020_05_31Request& request) const;
 
  template <typename CreateContinuousDeploymentPolicy2020_05_31RequestT = Model::CreateContinuousDeploymentPolicy2020_05_31Request>
  Model::CreateContinuousDeploymentPolicy2020_05_31OutcomeCallable CreateContinuousDeploymentPolicy2020_05_31Callable(
      const CreateContinuousDeploymentPolicy2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CreateContinuousDeploymentPolicy2020_05_31, request);
  }
 
  template <typename CreateContinuousDeploymentPolicy2020_05_31RequestT = Model::CreateContinuousDeploymentPolicy2020_05_31Request>
  void CreateContinuousDeploymentPolicy2020_05_31Async(
      const CreateContinuousDeploymentPolicy2020_05_31RequestT& request,
      const CreateContinuousDeploymentPolicy2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CreateContinuousDeploymentPolicy2020_05_31, request, handler, context);
  }
 
  virtual Model::CreateDistribution2020_05_31Outcome CreateDistribution2020_05_31(
      const Model::CreateDistribution2020_05_31Request& request) const;
 
  template <typename CreateDistribution2020_05_31RequestT = Model::CreateDistribution2020_05_31Request>
  Model::CreateDistribution2020_05_31OutcomeCallable CreateDistribution2020_05_31Callable(
      const CreateDistribution2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CreateDistribution2020_05_31, request);
  }
 
  template <typename CreateDistribution2020_05_31RequestT = Model::CreateDistribution2020_05_31Request>
  void CreateDistribution2020_05_31Async(const CreateDistribution2020_05_31RequestT& request,
                                         const CreateDistribution2020_05_31ResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CreateDistribution2020_05_31, request, handler, context);
  }
 
  virtual Model::CreateDistributionTenant2020_05_31Outcome CreateDistributionTenant2020_05_31(
      const Model::CreateDistributionTenant2020_05_31Request& request) const;
 
  template <typename CreateDistributionTenant2020_05_31RequestT = Model::CreateDistributionTenant2020_05_31Request>
  Model::CreateDistributionTenant2020_05_31OutcomeCallable CreateDistributionTenant2020_05_31Callable(
      const CreateDistributionTenant2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CreateDistributionTenant2020_05_31, request);
  }
 
  template <typename CreateDistributionTenant2020_05_31RequestT = Model::CreateDistributionTenant2020_05_31Request>
  void CreateDistributionTenant2020_05_31Async(const CreateDistributionTenant2020_05_31RequestT& request,
                                               const CreateDistributionTenant2020_05_31ResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CreateDistributionTenant2020_05_31, request, handler, context);
  }
 
  virtual Model::CreateDistributionWithTags2020_05_31Outcome CreateDistributionWithTags2020_05_31(
      const Model::CreateDistributionWithTags2020_05_31Request& request) const;
 
  template <typename CreateDistributionWithTags2020_05_31RequestT = Model::CreateDistributionWithTags2020_05_31Request>
  Model::CreateDistributionWithTags2020_05_31OutcomeCallable CreateDistributionWithTags2020_05_31Callable(
      const CreateDistributionWithTags2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CreateDistributionWithTags2020_05_31, request);
  }
 
  template <typename CreateDistributionWithTags2020_05_31RequestT = Model::CreateDistributionWithTags2020_05_31Request>
  void CreateDistributionWithTags2020_05_31Async(const CreateDistributionWithTags2020_05_31RequestT& request,
                                                 const CreateDistributionWithTags2020_05_31ResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CreateDistributionWithTags2020_05_31, request, handler, context);
  }
 
  virtual Model::CreateFieldLevelEncryptionConfig2020_05_31Outcome CreateFieldLevelEncryptionConfig2020_05_31(
      const Model::CreateFieldLevelEncryptionConfig2020_05_31Request& request) const;
 
  template <typename CreateFieldLevelEncryptionConfig2020_05_31RequestT = Model::CreateFieldLevelEncryptionConfig2020_05_31Request>
  Model::CreateFieldLevelEncryptionConfig2020_05_31OutcomeCallable CreateFieldLevelEncryptionConfig2020_05_31Callable(
      const CreateFieldLevelEncryptionConfig2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CreateFieldLevelEncryptionConfig2020_05_31, request);
  }
 
  template <typename CreateFieldLevelEncryptionConfig2020_05_31RequestT = Model::CreateFieldLevelEncryptionConfig2020_05_31Request>
  void CreateFieldLevelEncryptionConfig2020_05_31Async(
      const CreateFieldLevelEncryptionConfig2020_05_31RequestT& request,
      const CreateFieldLevelEncryptionConfig2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CreateFieldLevelEncryptionConfig2020_05_31, request, handler, context);
  }
 
  virtual Model::CreateFieldLevelEncryptionProfile2020_05_31Outcome CreateFieldLevelEncryptionProfile2020_05_31(
      const Model::CreateFieldLevelEncryptionProfile2020_05_31Request& request) const;
 
  template <typename CreateFieldLevelEncryptionProfile2020_05_31RequestT = Model::CreateFieldLevelEncryptionProfile2020_05_31Request>
  Model::CreateFieldLevelEncryptionProfile2020_05_31OutcomeCallable CreateFieldLevelEncryptionProfile2020_05_31Callable(
      const CreateFieldLevelEncryptionProfile2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CreateFieldLevelEncryptionProfile2020_05_31, request);
  }
 
  template <typename CreateFieldLevelEncryptionProfile2020_05_31RequestT = Model::CreateFieldLevelEncryptionProfile2020_05_31Request>
  void CreateFieldLevelEncryptionProfile2020_05_31Async(
      const CreateFieldLevelEncryptionProfile2020_05_31RequestT& request,
      const CreateFieldLevelEncryptionProfile2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CreateFieldLevelEncryptionProfile2020_05_31, request, handler, context);
  }
 
  virtual Model::CreateFunction2020_05_31Outcome CreateFunction2020_05_31(const Model::CreateFunction2020_05_31Request& request) const;
 
  template <typename CreateFunction2020_05_31RequestT = Model::CreateFunction2020_05_31Request>
  Model::CreateFunction2020_05_31OutcomeCallable CreateFunction2020_05_31Callable(const CreateFunction2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CreateFunction2020_05_31, request);
  }
 
  template <typename CreateFunction2020_05_31RequestT = Model::CreateFunction2020_05_31Request>
  void CreateFunction2020_05_31Async(const CreateFunction2020_05_31RequestT& request,
                                     const CreateFunction2020_05_31ResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CreateFunction2020_05_31, request, handler, context);
  }
 
  virtual Model::CreateInvalidation2020_05_31Outcome CreateInvalidation2020_05_31(
      const Model::CreateInvalidation2020_05_31Request& request) const;
 
  template <typename CreateInvalidation2020_05_31RequestT = Model::CreateInvalidation2020_05_31Request>
  Model::CreateInvalidation2020_05_31OutcomeCallable CreateInvalidation2020_05_31Callable(
      const CreateInvalidation2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CreateInvalidation2020_05_31, request);
  }
 
  template <typename CreateInvalidation2020_05_31RequestT = Model::CreateInvalidation2020_05_31Request>
  void CreateInvalidation2020_05_31Async(const CreateInvalidation2020_05_31RequestT& request,
                                         const CreateInvalidation2020_05_31ResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CreateInvalidation2020_05_31, request, handler, context);
  }
 
  virtual Model::CreateInvalidationForDistributionTenant2020_05_31Outcome CreateInvalidationForDistributionTenant2020_05_31(
      const Model::CreateInvalidationForDistributionTenant2020_05_31Request& request) const;
 
  template <
      typename CreateInvalidationForDistributionTenant2020_05_31RequestT = Model::CreateInvalidationForDistributionTenant2020_05_31Request>
  Model::CreateInvalidationForDistributionTenant2020_05_31OutcomeCallable CreateInvalidationForDistributionTenant2020_05_31Callable(
      const CreateInvalidationForDistributionTenant2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CreateInvalidationForDistributionTenant2020_05_31, request);
  }
 
  template <
      typename CreateInvalidationForDistributionTenant2020_05_31RequestT = Model::CreateInvalidationForDistributionTenant2020_05_31Request>
  void CreateInvalidationForDistributionTenant2020_05_31Async(
      const CreateInvalidationForDistributionTenant2020_05_31RequestT& request,
      const CreateInvalidationForDistributionTenant2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CreateInvalidationForDistributionTenant2020_05_31, request, handler, context);
  }
 
  virtual Model::CreateKeyGroup2020_05_31Outcome CreateKeyGroup2020_05_31(const Model::CreateKeyGroup2020_05_31Request& request) const;
 
  template <typename CreateKeyGroup2020_05_31RequestT = Model::CreateKeyGroup2020_05_31Request>
  Model::CreateKeyGroup2020_05_31OutcomeCallable CreateKeyGroup2020_05_31Callable(const CreateKeyGroup2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CreateKeyGroup2020_05_31, request);
  }
 
  template <typename CreateKeyGroup2020_05_31RequestT = Model::CreateKeyGroup2020_05_31Request>
  void CreateKeyGroup2020_05_31Async(const CreateKeyGroup2020_05_31RequestT& request,
                                     const CreateKeyGroup2020_05_31ResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CreateKeyGroup2020_05_31, request, handler, context);
  }
 
  virtual Model::CreateKeyValueStore2020_05_31Outcome CreateKeyValueStore2020_05_31(
      const Model::CreateKeyValueStore2020_05_31Request& request) const;
 
  template <typename CreateKeyValueStore2020_05_31RequestT = Model::CreateKeyValueStore2020_05_31Request>
  Model::CreateKeyValueStore2020_05_31OutcomeCallable CreateKeyValueStore2020_05_31Callable(
      const CreateKeyValueStore2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CreateKeyValueStore2020_05_31, request);
  }
 
  template <typename CreateKeyValueStore2020_05_31RequestT = Model::CreateKeyValueStore2020_05_31Request>
  void CreateKeyValueStore2020_05_31Async(const CreateKeyValueStore2020_05_31RequestT& request,
                                          const CreateKeyValueStore2020_05_31ResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CreateKeyValueStore2020_05_31, request, handler, context);
  }
 
  virtual Model::CreateMonitoringSubscription2020_05_31Outcome CreateMonitoringSubscription2020_05_31(
      const Model::CreateMonitoringSubscription2020_05_31Request& request) const;
 
  template <typename CreateMonitoringSubscription2020_05_31RequestT = Model::CreateMonitoringSubscription2020_05_31Request>
  Model::CreateMonitoringSubscription2020_05_31OutcomeCallable CreateMonitoringSubscription2020_05_31Callable(
      const CreateMonitoringSubscription2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CreateMonitoringSubscription2020_05_31, request);
  }
 
  template <typename CreateMonitoringSubscription2020_05_31RequestT = Model::CreateMonitoringSubscription2020_05_31Request>
  void CreateMonitoringSubscription2020_05_31Async(const CreateMonitoringSubscription2020_05_31RequestT& request,
                                                   const CreateMonitoringSubscription2020_05_31ResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CreateMonitoringSubscription2020_05_31, request, handler, context);
  }
 
  virtual Model::CreateOriginAccessControl2020_05_31Outcome CreateOriginAccessControl2020_05_31(
      const Model::CreateOriginAccessControl2020_05_31Request& request) const;
 
  template <typename CreateOriginAccessControl2020_05_31RequestT = Model::CreateOriginAccessControl2020_05_31Request>
  Model::CreateOriginAccessControl2020_05_31OutcomeCallable CreateOriginAccessControl2020_05_31Callable(
      const CreateOriginAccessControl2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CreateOriginAccessControl2020_05_31, request);
  }
 
  template <typename CreateOriginAccessControl2020_05_31RequestT = Model::CreateOriginAccessControl2020_05_31Request>
  void CreateOriginAccessControl2020_05_31Async(const CreateOriginAccessControl2020_05_31RequestT& request,
                                                const CreateOriginAccessControl2020_05_31ResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CreateOriginAccessControl2020_05_31, request, handler, context);
  }
 
  virtual Model::CreateOriginRequestPolicy2020_05_31Outcome CreateOriginRequestPolicy2020_05_31(
      const Model::CreateOriginRequestPolicy2020_05_31Request& request) const;
 
  template <typename CreateOriginRequestPolicy2020_05_31RequestT = Model::CreateOriginRequestPolicy2020_05_31Request>
  Model::CreateOriginRequestPolicy2020_05_31OutcomeCallable CreateOriginRequestPolicy2020_05_31Callable(
      const CreateOriginRequestPolicy2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CreateOriginRequestPolicy2020_05_31, request);
  }
 
  template <typename CreateOriginRequestPolicy2020_05_31RequestT = Model::CreateOriginRequestPolicy2020_05_31Request>
  void CreateOriginRequestPolicy2020_05_31Async(const CreateOriginRequestPolicy2020_05_31RequestT& request,
                                                const CreateOriginRequestPolicy2020_05_31ResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CreateOriginRequestPolicy2020_05_31, request, handler, context);
  }
 
  virtual Model::CreatePublicKey2020_05_31Outcome CreatePublicKey2020_05_31(const Model::CreatePublicKey2020_05_31Request& request) const;
 
  template <typename CreatePublicKey2020_05_31RequestT = Model::CreatePublicKey2020_05_31Request>
  Model::CreatePublicKey2020_05_31OutcomeCallable CreatePublicKey2020_05_31Callable(
      const CreatePublicKey2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CreatePublicKey2020_05_31, request);
  }
 
  template <typename CreatePublicKey2020_05_31RequestT = Model::CreatePublicKey2020_05_31Request>
  void CreatePublicKey2020_05_31Async(const CreatePublicKey2020_05_31RequestT& request,
                                      const CreatePublicKey2020_05_31ResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CreatePublicKey2020_05_31, request, handler, context);
  }
 
  virtual Model::CreateRealtimeLogConfig2020_05_31Outcome CreateRealtimeLogConfig2020_05_31(
      const Model::CreateRealtimeLogConfig2020_05_31Request& request) const;
 
  template <typename CreateRealtimeLogConfig2020_05_31RequestT = Model::CreateRealtimeLogConfig2020_05_31Request>
  Model::CreateRealtimeLogConfig2020_05_31OutcomeCallable CreateRealtimeLogConfig2020_05_31Callable(
      const CreateRealtimeLogConfig2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CreateRealtimeLogConfig2020_05_31, request);
  }
 
  template <typename CreateRealtimeLogConfig2020_05_31RequestT = Model::CreateRealtimeLogConfig2020_05_31Request>
  void CreateRealtimeLogConfig2020_05_31Async(const CreateRealtimeLogConfig2020_05_31RequestT& request,
                                              const CreateRealtimeLogConfig2020_05_31ResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CreateRealtimeLogConfig2020_05_31, request, handler, context);
  }
 
  virtual Model::CreateResponseHeadersPolicy2020_05_31Outcome CreateResponseHeadersPolicy2020_05_31(
      const Model::CreateResponseHeadersPolicy2020_05_31Request& request) const;
 
  template <typename CreateResponseHeadersPolicy2020_05_31RequestT = Model::CreateResponseHeadersPolicy2020_05_31Request>
  Model::CreateResponseHeadersPolicy2020_05_31OutcomeCallable CreateResponseHeadersPolicy2020_05_31Callable(
      const CreateResponseHeadersPolicy2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CreateResponseHeadersPolicy2020_05_31, request);
  }
 
  template <typename CreateResponseHeadersPolicy2020_05_31RequestT = Model::CreateResponseHeadersPolicy2020_05_31Request>
  void CreateResponseHeadersPolicy2020_05_31Async(const CreateResponseHeadersPolicy2020_05_31RequestT& request,
                                                  const CreateResponseHeadersPolicy2020_05_31ResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CreateResponseHeadersPolicy2020_05_31, request, handler, context);
  }
 
  virtual Model::CreateStreamingDistribution2020_05_31Outcome CreateStreamingDistribution2020_05_31(
      const Model::CreateStreamingDistribution2020_05_31Request& request) const;
 
  template <typename CreateStreamingDistribution2020_05_31RequestT = Model::CreateStreamingDistribution2020_05_31Request>
  Model::CreateStreamingDistribution2020_05_31OutcomeCallable CreateStreamingDistribution2020_05_31Callable(
      const CreateStreamingDistribution2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CreateStreamingDistribution2020_05_31, request);
  }
 
  template <typename CreateStreamingDistribution2020_05_31RequestT = Model::CreateStreamingDistribution2020_05_31Request>
  void CreateStreamingDistribution2020_05_31Async(const CreateStreamingDistribution2020_05_31RequestT& request,
                                                  const CreateStreamingDistribution2020_05_31ResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CreateStreamingDistribution2020_05_31, request, handler, context);
  }
 
  virtual Model::CreateStreamingDistributionWithTags2020_05_31Outcome CreateStreamingDistributionWithTags2020_05_31(
      const Model::CreateStreamingDistributionWithTags2020_05_31Request& request) const;
 
  template <typename CreateStreamingDistributionWithTags2020_05_31RequestT = Model::CreateStreamingDistributionWithTags2020_05_31Request>
  Model::CreateStreamingDistributionWithTags2020_05_31OutcomeCallable CreateStreamingDistributionWithTags2020_05_31Callable(
      const CreateStreamingDistributionWithTags2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CreateStreamingDistributionWithTags2020_05_31, request);
  }
 
  template <typename CreateStreamingDistributionWithTags2020_05_31RequestT = Model::CreateStreamingDistributionWithTags2020_05_31Request>
  void CreateStreamingDistributionWithTags2020_05_31Async(
      const CreateStreamingDistributionWithTags2020_05_31RequestT& request,
      const CreateStreamingDistributionWithTags2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CreateStreamingDistributionWithTags2020_05_31, request, handler, context);
  }
 
  virtual Model::CreateTrustStore2020_05_31Outcome CreateTrustStore2020_05_31(
      const Model::CreateTrustStore2020_05_31Request& request) const;
 
  template <typename CreateTrustStore2020_05_31RequestT = Model::CreateTrustStore2020_05_31Request>
  Model::CreateTrustStore2020_05_31OutcomeCallable CreateTrustStore2020_05_31Callable(
      const CreateTrustStore2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CreateTrustStore2020_05_31, request);
  }
 
  template <typename CreateTrustStore2020_05_31RequestT = Model::CreateTrustStore2020_05_31Request>
  void CreateTrustStore2020_05_31Async(const CreateTrustStore2020_05_31RequestT& request,
                                       const CreateTrustStore2020_05_31ResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CreateTrustStore2020_05_31, request, handler, context);
  }
 
  virtual Model::CreateVpcOrigin2020_05_31Outcome CreateVpcOrigin2020_05_31(const Model::CreateVpcOrigin2020_05_31Request& request) const;
 
  template <typename CreateVpcOrigin2020_05_31RequestT = Model::CreateVpcOrigin2020_05_31Request>
  Model::CreateVpcOrigin2020_05_31OutcomeCallable CreateVpcOrigin2020_05_31Callable(
      const CreateVpcOrigin2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::CreateVpcOrigin2020_05_31, request);
  }
 
  template <typename CreateVpcOrigin2020_05_31RequestT = Model::CreateVpcOrigin2020_05_31Request>
  void CreateVpcOrigin2020_05_31Async(const CreateVpcOrigin2020_05_31RequestT& request,
                                      const CreateVpcOrigin2020_05_31ResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::CreateVpcOrigin2020_05_31, request, handler, context);
  }
 
  virtual Model::DeleteAnycastIpList2020_05_31Outcome DeleteAnycastIpList2020_05_31(
      const Model::DeleteAnycastIpList2020_05_31Request& request) const;
 
  template <typename DeleteAnycastIpList2020_05_31RequestT = Model::DeleteAnycastIpList2020_05_31Request>
  Model::DeleteAnycastIpList2020_05_31OutcomeCallable DeleteAnycastIpList2020_05_31Callable(
      const DeleteAnycastIpList2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DeleteAnycastIpList2020_05_31, request);
  }
 
  template <typename DeleteAnycastIpList2020_05_31RequestT = Model::DeleteAnycastIpList2020_05_31Request>
  void DeleteAnycastIpList2020_05_31Async(const DeleteAnycastIpList2020_05_31RequestT& request,
                                          const DeleteAnycastIpList2020_05_31ResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DeleteAnycastIpList2020_05_31, request, handler, context);
  }
 
  virtual Model::DeleteCachePolicy2020_05_31Outcome DeleteCachePolicy2020_05_31(
      const Model::DeleteCachePolicy2020_05_31Request& request) const;
 
  template <typename DeleteCachePolicy2020_05_31RequestT = Model::DeleteCachePolicy2020_05_31Request>
  Model::DeleteCachePolicy2020_05_31OutcomeCallable DeleteCachePolicy2020_05_31Callable(
      const DeleteCachePolicy2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DeleteCachePolicy2020_05_31, request);
  }
 
  template <typename DeleteCachePolicy2020_05_31RequestT = Model::DeleteCachePolicy2020_05_31Request>
  void DeleteCachePolicy2020_05_31Async(const DeleteCachePolicy2020_05_31RequestT& request,
                                        const DeleteCachePolicy2020_05_31ResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DeleteCachePolicy2020_05_31, request, handler, context);
  }
 
  virtual Model::DeleteCloudFrontOriginAccessIdentity2020_05_31Outcome DeleteCloudFrontOriginAccessIdentity2020_05_31(
      const Model::DeleteCloudFrontOriginAccessIdentity2020_05_31Request& request) const;
 
  template <typename DeleteCloudFrontOriginAccessIdentity2020_05_31RequestT = Model::DeleteCloudFrontOriginAccessIdentity2020_05_31Request>
  Model::DeleteCloudFrontOriginAccessIdentity2020_05_31OutcomeCallable DeleteCloudFrontOriginAccessIdentity2020_05_31Callable(
      const DeleteCloudFrontOriginAccessIdentity2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DeleteCloudFrontOriginAccessIdentity2020_05_31, request);
  }
 
  template <typename DeleteCloudFrontOriginAccessIdentity2020_05_31RequestT = Model::DeleteCloudFrontOriginAccessIdentity2020_05_31Request>
  void DeleteCloudFrontOriginAccessIdentity2020_05_31Async(
      const DeleteCloudFrontOriginAccessIdentity2020_05_31RequestT& request,
      const DeleteCloudFrontOriginAccessIdentity2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DeleteCloudFrontOriginAccessIdentity2020_05_31, request, handler, context);
  }
 
  virtual Model::DeleteConnectionFunction2020_05_31Outcome DeleteConnectionFunction2020_05_31(
      const Model::DeleteConnectionFunction2020_05_31Request& request) const;
 
  template <typename DeleteConnectionFunction2020_05_31RequestT = Model::DeleteConnectionFunction2020_05_31Request>
  Model::DeleteConnectionFunction2020_05_31OutcomeCallable DeleteConnectionFunction2020_05_31Callable(
      const DeleteConnectionFunction2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DeleteConnectionFunction2020_05_31, request);
  }
 
  template <typename DeleteConnectionFunction2020_05_31RequestT = Model::DeleteConnectionFunction2020_05_31Request>
  void DeleteConnectionFunction2020_05_31Async(const DeleteConnectionFunction2020_05_31RequestT& request,
                                               const DeleteConnectionFunction2020_05_31ResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DeleteConnectionFunction2020_05_31, request, handler, context);
  }
 
  virtual Model::DeleteConnectionGroup2020_05_31Outcome DeleteConnectionGroup2020_05_31(
      const Model::DeleteConnectionGroup2020_05_31Request& request) const;
 
  template <typename DeleteConnectionGroup2020_05_31RequestT = Model::DeleteConnectionGroup2020_05_31Request>
  Model::DeleteConnectionGroup2020_05_31OutcomeCallable DeleteConnectionGroup2020_05_31Callable(
      const DeleteConnectionGroup2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DeleteConnectionGroup2020_05_31, request);
  }
 
  template <typename DeleteConnectionGroup2020_05_31RequestT = Model::DeleteConnectionGroup2020_05_31Request>
  void DeleteConnectionGroup2020_05_31Async(const DeleteConnectionGroup2020_05_31RequestT& request,
                                            const DeleteConnectionGroup2020_05_31ResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DeleteConnectionGroup2020_05_31, request, handler, context);
  }
 
  virtual Model::DeleteContinuousDeploymentPolicy2020_05_31Outcome DeleteContinuousDeploymentPolicy2020_05_31(
      const Model::DeleteContinuousDeploymentPolicy2020_05_31Request& request) const;
 
  template <typename DeleteContinuousDeploymentPolicy2020_05_31RequestT = Model::DeleteContinuousDeploymentPolicy2020_05_31Request>
  Model::DeleteContinuousDeploymentPolicy2020_05_31OutcomeCallable DeleteContinuousDeploymentPolicy2020_05_31Callable(
      const DeleteContinuousDeploymentPolicy2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DeleteContinuousDeploymentPolicy2020_05_31, request);
  }
 
  template <typename DeleteContinuousDeploymentPolicy2020_05_31RequestT = Model::DeleteContinuousDeploymentPolicy2020_05_31Request>
  void DeleteContinuousDeploymentPolicy2020_05_31Async(
      const DeleteContinuousDeploymentPolicy2020_05_31RequestT& request,
      const DeleteContinuousDeploymentPolicy2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DeleteContinuousDeploymentPolicy2020_05_31, request, handler, context);
  }
 
  virtual Model::DeleteDistribution2020_05_31Outcome DeleteDistribution2020_05_31(
      const Model::DeleteDistribution2020_05_31Request& request) const;
 
  template <typename DeleteDistribution2020_05_31RequestT = Model::DeleteDistribution2020_05_31Request>
  Model::DeleteDistribution2020_05_31OutcomeCallable DeleteDistribution2020_05_31Callable(
      const DeleteDistribution2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DeleteDistribution2020_05_31, request);
  }
 
  template <typename DeleteDistribution2020_05_31RequestT = Model::DeleteDistribution2020_05_31Request>
  void DeleteDistribution2020_05_31Async(const DeleteDistribution2020_05_31RequestT& request,
                                         const DeleteDistribution2020_05_31ResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DeleteDistribution2020_05_31, request, handler, context);
  }
 
  virtual Model::DeleteDistributionTenant2020_05_31Outcome DeleteDistributionTenant2020_05_31(
      const Model::DeleteDistributionTenant2020_05_31Request& request) const;
 
  template <typename DeleteDistributionTenant2020_05_31RequestT = Model::DeleteDistributionTenant2020_05_31Request>
  Model::DeleteDistributionTenant2020_05_31OutcomeCallable DeleteDistributionTenant2020_05_31Callable(
      const DeleteDistributionTenant2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DeleteDistributionTenant2020_05_31, request);
  }
 
  template <typename DeleteDistributionTenant2020_05_31RequestT = Model::DeleteDistributionTenant2020_05_31Request>
  void DeleteDistributionTenant2020_05_31Async(const DeleteDistributionTenant2020_05_31RequestT& request,
                                               const DeleteDistributionTenant2020_05_31ResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DeleteDistributionTenant2020_05_31, request, handler, context);
  }
 
  virtual Model::DeleteFieldLevelEncryptionConfig2020_05_31Outcome DeleteFieldLevelEncryptionConfig2020_05_31(
      const Model::DeleteFieldLevelEncryptionConfig2020_05_31Request& request) const;
 
  template <typename DeleteFieldLevelEncryptionConfig2020_05_31RequestT = Model::DeleteFieldLevelEncryptionConfig2020_05_31Request>
  Model::DeleteFieldLevelEncryptionConfig2020_05_31OutcomeCallable DeleteFieldLevelEncryptionConfig2020_05_31Callable(
      const DeleteFieldLevelEncryptionConfig2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DeleteFieldLevelEncryptionConfig2020_05_31, request);
  }
 
  template <typename DeleteFieldLevelEncryptionConfig2020_05_31RequestT = Model::DeleteFieldLevelEncryptionConfig2020_05_31Request>
  void DeleteFieldLevelEncryptionConfig2020_05_31Async(
      const DeleteFieldLevelEncryptionConfig2020_05_31RequestT& request,
      const DeleteFieldLevelEncryptionConfig2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DeleteFieldLevelEncryptionConfig2020_05_31, request, handler, context);
  }
 
  virtual Model::DeleteFieldLevelEncryptionProfile2020_05_31Outcome DeleteFieldLevelEncryptionProfile2020_05_31(
      const Model::DeleteFieldLevelEncryptionProfile2020_05_31Request& request) const;
 
  template <typename DeleteFieldLevelEncryptionProfile2020_05_31RequestT = Model::DeleteFieldLevelEncryptionProfile2020_05_31Request>
  Model::DeleteFieldLevelEncryptionProfile2020_05_31OutcomeCallable DeleteFieldLevelEncryptionProfile2020_05_31Callable(
      const DeleteFieldLevelEncryptionProfile2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DeleteFieldLevelEncryptionProfile2020_05_31, request);
  }
 
  template <typename DeleteFieldLevelEncryptionProfile2020_05_31RequestT = Model::DeleteFieldLevelEncryptionProfile2020_05_31Request>
  void DeleteFieldLevelEncryptionProfile2020_05_31Async(
      const DeleteFieldLevelEncryptionProfile2020_05_31RequestT& request,
      const DeleteFieldLevelEncryptionProfile2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DeleteFieldLevelEncryptionProfile2020_05_31, request, handler, context);
  }
 
  virtual Model::DeleteFunction2020_05_31Outcome DeleteFunction2020_05_31(const Model::DeleteFunction2020_05_31Request& request) const;
 
  template <typename DeleteFunction2020_05_31RequestT = Model::DeleteFunction2020_05_31Request>
  Model::DeleteFunction2020_05_31OutcomeCallable DeleteFunction2020_05_31Callable(const DeleteFunction2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DeleteFunction2020_05_31, request);
  }
 
  template <typename DeleteFunction2020_05_31RequestT = Model::DeleteFunction2020_05_31Request>
  void DeleteFunction2020_05_31Async(const DeleteFunction2020_05_31RequestT& request,
                                     const DeleteFunction2020_05_31ResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DeleteFunction2020_05_31, request, handler, context);
  }
 
  virtual Model::DeleteKeyGroup2020_05_31Outcome DeleteKeyGroup2020_05_31(const Model::DeleteKeyGroup2020_05_31Request& request) const;
 
  template <typename DeleteKeyGroup2020_05_31RequestT = Model::DeleteKeyGroup2020_05_31Request>
  Model::DeleteKeyGroup2020_05_31OutcomeCallable DeleteKeyGroup2020_05_31Callable(const DeleteKeyGroup2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DeleteKeyGroup2020_05_31, request);
  }
 
  template <typename DeleteKeyGroup2020_05_31RequestT = Model::DeleteKeyGroup2020_05_31Request>
  void DeleteKeyGroup2020_05_31Async(const DeleteKeyGroup2020_05_31RequestT& request,
                                     const DeleteKeyGroup2020_05_31ResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DeleteKeyGroup2020_05_31, request, handler, context);
  }
 
  virtual Model::DeleteKeyValueStore2020_05_31Outcome DeleteKeyValueStore2020_05_31(
      const Model::DeleteKeyValueStore2020_05_31Request& request) const;
 
  template <typename DeleteKeyValueStore2020_05_31RequestT = Model::DeleteKeyValueStore2020_05_31Request>
  Model::DeleteKeyValueStore2020_05_31OutcomeCallable DeleteKeyValueStore2020_05_31Callable(
      const DeleteKeyValueStore2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DeleteKeyValueStore2020_05_31, request);
  }
 
  template <typename DeleteKeyValueStore2020_05_31RequestT = Model::DeleteKeyValueStore2020_05_31Request>
  void DeleteKeyValueStore2020_05_31Async(const DeleteKeyValueStore2020_05_31RequestT& request,
                                          const DeleteKeyValueStore2020_05_31ResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DeleteKeyValueStore2020_05_31, request, handler, context);
  }
 
  virtual Model::DeleteMonitoringSubscription2020_05_31Outcome DeleteMonitoringSubscription2020_05_31(
      const Model::DeleteMonitoringSubscription2020_05_31Request& request) const;
 
  template <typename DeleteMonitoringSubscription2020_05_31RequestT = Model::DeleteMonitoringSubscription2020_05_31Request>
  Model::DeleteMonitoringSubscription2020_05_31OutcomeCallable DeleteMonitoringSubscription2020_05_31Callable(
      const DeleteMonitoringSubscription2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DeleteMonitoringSubscription2020_05_31, request);
  }
 
  template <typename DeleteMonitoringSubscription2020_05_31RequestT = Model::DeleteMonitoringSubscription2020_05_31Request>
  void DeleteMonitoringSubscription2020_05_31Async(const DeleteMonitoringSubscription2020_05_31RequestT& request,
                                                   const DeleteMonitoringSubscription2020_05_31ResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DeleteMonitoringSubscription2020_05_31, request, handler, context);
  }
 
  virtual Model::DeleteOriginAccessControl2020_05_31Outcome DeleteOriginAccessControl2020_05_31(
      const Model::DeleteOriginAccessControl2020_05_31Request& request) const;
 
  template <typename DeleteOriginAccessControl2020_05_31RequestT = Model::DeleteOriginAccessControl2020_05_31Request>
  Model::DeleteOriginAccessControl2020_05_31OutcomeCallable DeleteOriginAccessControl2020_05_31Callable(
      const DeleteOriginAccessControl2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DeleteOriginAccessControl2020_05_31, request);
  }
 
  template <typename DeleteOriginAccessControl2020_05_31RequestT = Model::DeleteOriginAccessControl2020_05_31Request>
  void DeleteOriginAccessControl2020_05_31Async(const DeleteOriginAccessControl2020_05_31RequestT& request,
                                                const DeleteOriginAccessControl2020_05_31ResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DeleteOriginAccessControl2020_05_31, request, handler, context);
  }
 
  virtual Model::DeleteOriginRequestPolicy2020_05_31Outcome DeleteOriginRequestPolicy2020_05_31(
      const Model::DeleteOriginRequestPolicy2020_05_31Request& request) const;
 
  template <typename DeleteOriginRequestPolicy2020_05_31RequestT = Model::DeleteOriginRequestPolicy2020_05_31Request>
  Model::DeleteOriginRequestPolicy2020_05_31OutcomeCallable DeleteOriginRequestPolicy2020_05_31Callable(
      const DeleteOriginRequestPolicy2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DeleteOriginRequestPolicy2020_05_31, request);
  }
 
  template <typename DeleteOriginRequestPolicy2020_05_31RequestT = Model::DeleteOriginRequestPolicy2020_05_31Request>
  void DeleteOriginRequestPolicy2020_05_31Async(const DeleteOriginRequestPolicy2020_05_31RequestT& request,
                                                const DeleteOriginRequestPolicy2020_05_31ResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DeleteOriginRequestPolicy2020_05_31, request, handler, context);
  }
 
  virtual Model::DeletePublicKey2020_05_31Outcome DeletePublicKey2020_05_31(const Model::DeletePublicKey2020_05_31Request& request) const;
 
  template <typename DeletePublicKey2020_05_31RequestT = Model::DeletePublicKey2020_05_31Request>
  Model::DeletePublicKey2020_05_31OutcomeCallable DeletePublicKey2020_05_31Callable(
      const DeletePublicKey2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DeletePublicKey2020_05_31, request);
  }
 
  template <typename DeletePublicKey2020_05_31RequestT = Model::DeletePublicKey2020_05_31Request>
  void DeletePublicKey2020_05_31Async(const DeletePublicKey2020_05_31RequestT& request,
                                      const DeletePublicKey2020_05_31ResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DeletePublicKey2020_05_31, request, handler, context);
  }
 
  virtual Model::DeleteRealtimeLogConfig2020_05_31Outcome DeleteRealtimeLogConfig2020_05_31(
      const Model::DeleteRealtimeLogConfig2020_05_31Request& request = {}) const;
 
  template <typename DeleteRealtimeLogConfig2020_05_31RequestT = Model::DeleteRealtimeLogConfig2020_05_31Request>
  Model::DeleteRealtimeLogConfig2020_05_31OutcomeCallable DeleteRealtimeLogConfig2020_05_31Callable(
      const DeleteRealtimeLogConfig2020_05_31RequestT& request = {}) const {
    return SubmitCallable(&CloudFrontClient::DeleteRealtimeLogConfig2020_05_31, request);
  }
 
  template <typename DeleteRealtimeLogConfig2020_05_31RequestT = Model::DeleteRealtimeLogConfig2020_05_31Request>
  void DeleteRealtimeLogConfig2020_05_31Async(const DeleteRealtimeLogConfig2020_05_31ResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const DeleteRealtimeLogConfig2020_05_31RequestT& request = {}) const {
    return SubmitAsync(&CloudFrontClient::DeleteRealtimeLogConfig2020_05_31, request, handler, context);
  }
 
  virtual Model::DeleteResourcePolicy2020_05_31Outcome DeleteResourcePolicy2020_05_31(
      const Model::DeleteResourcePolicy2020_05_31Request& request) const;
 
  template <typename DeleteResourcePolicy2020_05_31RequestT = Model::DeleteResourcePolicy2020_05_31Request>
  Model::DeleteResourcePolicy2020_05_31OutcomeCallable DeleteResourcePolicy2020_05_31Callable(
      const DeleteResourcePolicy2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DeleteResourcePolicy2020_05_31, request);
  }
 
  template <typename DeleteResourcePolicy2020_05_31RequestT = Model::DeleteResourcePolicy2020_05_31Request>
  void DeleteResourcePolicy2020_05_31Async(const DeleteResourcePolicy2020_05_31RequestT& request,
                                           const DeleteResourcePolicy2020_05_31ResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DeleteResourcePolicy2020_05_31, request, handler, context);
  }
 
  virtual Model::DeleteResponseHeadersPolicy2020_05_31Outcome DeleteResponseHeadersPolicy2020_05_31(
      const Model::DeleteResponseHeadersPolicy2020_05_31Request& request) const;
 
  template <typename DeleteResponseHeadersPolicy2020_05_31RequestT = Model::DeleteResponseHeadersPolicy2020_05_31Request>
  Model::DeleteResponseHeadersPolicy2020_05_31OutcomeCallable DeleteResponseHeadersPolicy2020_05_31Callable(
      const DeleteResponseHeadersPolicy2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DeleteResponseHeadersPolicy2020_05_31, request);
  }
 
  template <typename DeleteResponseHeadersPolicy2020_05_31RequestT = Model::DeleteResponseHeadersPolicy2020_05_31Request>
  void DeleteResponseHeadersPolicy2020_05_31Async(const DeleteResponseHeadersPolicy2020_05_31RequestT& request,
                                                  const DeleteResponseHeadersPolicy2020_05_31ResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DeleteResponseHeadersPolicy2020_05_31, request, handler, context);
  }
 
  virtual Model::DeleteStreamingDistribution2020_05_31Outcome DeleteStreamingDistribution2020_05_31(
      const Model::DeleteStreamingDistribution2020_05_31Request& request) const;
 
  template <typename DeleteStreamingDistribution2020_05_31RequestT = Model::DeleteStreamingDistribution2020_05_31Request>
  Model::DeleteStreamingDistribution2020_05_31OutcomeCallable DeleteStreamingDistribution2020_05_31Callable(
      const DeleteStreamingDistribution2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DeleteStreamingDistribution2020_05_31, request);
  }
 
  template <typename DeleteStreamingDistribution2020_05_31RequestT = Model::DeleteStreamingDistribution2020_05_31Request>
  void DeleteStreamingDistribution2020_05_31Async(const DeleteStreamingDistribution2020_05_31RequestT& request,
                                                  const DeleteStreamingDistribution2020_05_31ResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DeleteStreamingDistribution2020_05_31, request, handler, context);
  }
 
  virtual Model::DeleteTrustStore2020_05_31Outcome DeleteTrustStore2020_05_31(
      const Model::DeleteTrustStore2020_05_31Request& request) const;
 
  template <typename DeleteTrustStore2020_05_31RequestT = Model::DeleteTrustStore2020_05_31Request>
  Model::DeleteTrustStore2020_05_31OutcomeCallable DeleteTrustStore2020_05_31Callable(
      const DeleteTrustStore2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DeleteTrustStore2020_05_31, request);
  }
 
  template <typename DeleteTrustStore2020_05_31RequestT = Model::DeleteTrustStore2020_05_31Request>
  void DeleteTrustStore2020_05_31Async(const DeleteTrustStore2020_05_31RequestT& request,
                                       const DeleteTrustStore2020_05_31ResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DeleteTrustStore2020_05_31, request, handler, context);
  }
 
  virtual Model::DeleteVpcOrigin2020_05_31Outcome DeleteVpcOrigin2020_05_31(const Model::DeleteVpcOrigin2020_05_31Request& request) const;
 
  template <typename DeleteVpcOrigin2020_05_31RequestT = Model::DeleteVpcOrigin2020_05_31Request>
  Model::DeleteVpcOrigin2020_05_31OutcomeCallable DeleteVpcOrigin2020_05_31Callable(
      const DeleteVpcOrigin2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DeleteVpcOrigin2020_05_31, request);
  }
 
  template <typename DeleteVpcOrigin2020_05_31RequestT = Model::DeleteVpcOrigin2020_05_31Request>
  void DeleteVpcOrigin2020_05_31Async(const DeleteVpcOrigin2020_05_31RequestT& request,
                                      const DeleteVpcOrigin2020_05_31ResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DeleteVpcOrigin2020_05_31, request, handler, context);
  }
 
  virtual Model::DescribeConnectionFunction2020_05_31Outcome DescribeConnectionFunction2020_05_31(
      const Model::DescribeConnectionFunction2020_05_31Request& request) const;
 
  template <typename DescribeConnectionFunction2020_05_31RequestT = Model::DescribeConnectionFunction2020_05_31Request>
  Model::DescribeConnectionFunction2020_05_31OutcomeCallable DescribeConnectionFunction2020_05_31Callable(
      const DescribeConnectionFunction2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DescribeConnectionFunction2020_05_31, request);
  }
 
  template <typename DescribeConnectionFunction2020_05_31RequestT = Model::DescribeConnectionFunction2020_05_31Request>
  void DescribeConnectionFunction2020_05_31Async(const DescribeConnectionFunction2020_05_31RequestT& request,
                                                 const DescribeConnectionFunction2020_05_31ResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DescribeConnectionFunction2020_05_31, request, handler, context);
  }
 
  virtual Model::DescribeFunction2020_05_31Outcome DescribeFunction2020_05_31(
      const Model::DescribeFunction2020_05_31Request& request) const;
 
  template <typename DescribeFunction2020_05_31RequestT = Model::DescribeFunction2020_05_31Request>
  Model::DescribeFunction2020_05_31OutcomeCallable DescribeFunction2020_05_31Callable(
      const DescribeFunction2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DescribeFunction2020_05_31, request);
  }
 
  template <typename DescribeFunction2020_05_31RequestT = Model::DescribeFunction2020_05_31Request>
  void DescribeFunction2020_05_31Async(const DescribeFunction2020_05_31RequestT& request,
                                       const DescribeFunction2020_05_31ResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DescribeFunction2020_05_31, request, handler, context);
  }
 
  virtual Model::DescribeKeyValueStore2020_05_31Outcome DescribeKeyValueStore2020_05_31(
      const Model::DescribeKeyValueStore2020_05_31Request& request) const;
 
  template <typename DescribeKeyValueStore2020_05_31RequestT = Model::DescribeKeyValueStore2020_05_31Request>
  Model::DescribeKeyValueStore2020_05_31OutcomeCallable DescribeKeyValueStore2020_05_31Callable(
      const DescribeKeyValueStore2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DescribeKeyValueStore2020_05_31, request);
  }
 
  template <typename DescribeKeyValueStore2020_05_31RequestT = Model::DescribeKeyValueStore2020_05_31Request>
  void DescribeKeyValueStore2020_05_31Async(const DescribeKeyValueStore2020_05_31RequestT& request,
                                            const DescribeKeyValueStore2020_05_31ResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DescribeKeyValueStore2020_05_31, request, handler, context);
  }
 
  virtual Model::DisassociateDistributionTenantWebACL2020_05_31Outcome DisassociateDistributionTenantWebACL2020_05_31(
      const Model::DisassociateDistributionTenantWebACL2020_05_31Request& request) const;
 
  template <typename DisassociateDistributionTenantWebACL2020_05_31RequestT = Model::DisassociateDistributionTenantWebACL2020_05_31Request>
  Model::DisassociateDistributionTenantWebACL2020_05_31OutcomeCallable DisassociateDistributionTenantWebACL2020_05_31Callable(
      const DisassociateDistributionTenantWebACL2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DisassociateDistributionTenantWebACL2020_05_31, request);
  }
 
  template <typename DisassociateDistributionTenantWebACL2020_05_31RequestT = Model::DisassociateDistributionTenantWebACL2020_05_31Request>
  void DisassociateDistributionTenantWebACL2020_05_31Async(
      const DisassociateDistributionTenantWebACL2020_05_31RequestT& request,
      const DisassociateDistributionTenantWebACL2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DisassociateDistributionTenantWebACL2020_05_31, request, handler, context);
  }
 
  virtual Model::DisassociateDistributionWebACL2020_05_31Outcome DisassociateDistributionWebACL2020_05_31(
      const Model::DisassociateDistributionWebACL2020_05_31Request& request) const;
 
  template <typename DisassociateDistributionWebACL2020_05_31RequestT = Model::DisassociateDistributionWebACL2020_05_31Request>
  Model::DisassociateDistributionWebACL2020_05_31OutcomeCallable DisassociateDistributionWebACL2020_05_31Callable(
      const DisassociateDistributionWebACL2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::DisassociateDistributionWebACL2020_05_31, request);
  }
 
  template <typename DisassociateDistributionWebACL2020_05_31RequestT = Model::DisassociateDistributionWebACL2020_05_31Request>
  void DisassociateDistributionWebACL2020_05_31Async(
      const DisassociateDistributionWebACL2020_05_31RequestT& request,
      const DisassociateDistributionWebACL2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::DisassociateDistributionWebACL2020_05_31, request, handler, context);
  }
 
  virtual Model::GetAnycastIpList2020_05_31Outcome GetAnycastIpList2020_05_31(
      const Model::GetAnycastIpList2020_05_31Request& request) const;
 
  template <typename GetAnycastIpList2020_05_31RequestT = Model::GetAnycastIpList2020_05_31Request>
  Model::GetAnycastIpList2020_05_31OutcomeCallable GetAnycastIpList2020_05_31Callable(
      const GetAnycastIpList2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetAnycastIpList2020_05_31, request);
  }
 
  template <typename GetAnycastIpList2020_05_31RequestT = Model::GetAnycastIpList2020_05_31Request>
  void GetAnycastIpList2020_05_31Async(const GetAnycastIpList2020_05_31RequestT& request,
                                       const GetAnycastIpList2020_05_31ResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetAnycastIpList2020_05_31, request, handler, context);
  }
 
  virtual Model::GetCachePolicy2020_05_31Outcome GetCachePolicy2020_05_31(const Model::GetCachePolicy2020_05_31Request& request) const;
 
  template <typename GetCachePolicy2020_05_31RequestT = Model::GetCachePolicy2020_05_31Request>
  Model::GetCachePolicy2020_05_31OutcomeCallable GetCachePolicy2020_05_31Callable(const GetCachePolicy2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetCachePolicy2020_05_31, request);
  }
 
  template <typename GetCachePolicy2020_05_31RequestT = Model::GetCachePolicy2020_05_31Request>
  void GetCachePolicy2020_05_31Async(const GetCachePolicy2020_05_31RequestT& request,
                                     const GetCachePolicy2020_05_31ResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetCachePolicy2020_05_31, request, handler, context);
  }
 
  virtual Model::GetCachePolicyConfig2020_05_31Outcome GetCachePolicyConfig2020_05_31(
      const Model::GetCachePolicyConfig2020_05_31Request& request) const;
 
  template <typename GetCachePolicyConfig2020_05_31RequestT = Model::GetCachePolicyConfig2020_05_31Request>
  Model::GetCachePolicyConfig2020_05_31OutcomeCallable GetCachePolicyConfig2020_05_31Callable(
      const GetCachePolicyConfig2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetCachePolicyConfig2020_05_31, request);
  }
 
  template <typename GetCachePolicyConfig2020_05_31RequestT = Model::GetCachePolicyConfig2020_05_31Request>
  void GetCachePolicyConfig2020_05_31Async(const GetCachePolicyConfig2020_05_31RequestT& request,
                                           const GetCachePolicyConfig2020_05_31ResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetCachePolicyConfig2020_05_31, request, handler, context);
  }
 
  virtual Model::GetCloudFrontOriginAccessIdentity2020_05_31Outcome GetCloudFrontOriginAccessIdentity2020_05_31(
      const Model::GetCloudFrontOriginAccessIdentity2020_05_31Request& request) const;
 
  template <typename GetCloudFrontOriginAccessIdentity2020_05_31RequestT = Model::GetCloudFrontOriginAccessIdentity2020_05_31Request>
  Model::GetCloudFrontOriginAccessIdentity2020_05_31OutcomeCallable GetCloudFrontOriginAccessIdentity2020_05_31Callable(
      const GetCloudFrontOriginAccessIdentity2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetCloudFrontOriginAccessIdentity2020_05_31, request);
  }
 
  template <typename GetCloudFrontOriginAccessIdentity2020_05_31RequestT = Model::GetCloudFrontOriginAccessIdentity2020_05_31Request>
  void GetCloudFrontOriginAccessIdentity2020_05_31Async(
      const GetCloudFrontOriginAccessIdentity2020_05_31RequestT& request,
      const GetCloudFrontOriginAccessIdentity2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetCloudFrontOriginAccessIdentity2020_05_31, request, handler, context);
  }
 
  virtual Model::GetCloudFrontOriginAccessIdentityConfig2020_05_31Outcome GetCloudFrontOriginAccessIdentityConfig2020_05_31(
      const Model::GetCloudFrontOriginAccessIdentityConfig2020_05_31Request& request) const;
 
  template <
      typename GetCloudFrontOriginAccessIdentityConfig2020_05_31RequestT = Model::GetCloudFrontOriginAccessIdentityConfig2020_05_31Request>
  Model::GetCloudFrontOriginAccessIdentityConfig2020_05_31OutcomeCallable GetCloudFrontOriginAccessIdentityConfig2020_05_31Callable(
      const GetCloudFrontOriginAccessIdentityConfig2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetCloudFrontOriginAccessIdentityConfig2020_05_31, request);
  }
 
  template <
      typename GetCloudFrontOriginAccessIdentityConfig2020_05_31RequestT = Model::GetCloudFrontOriginAccessIdentityConfig2020_05_31Request>
  void GetCloudFrontOriginAccessIdentityConfig2020_05_31Async(
      const GetCloudFrontOriginAccessIdentityConfig2020_05_31RequestT& request,
      const GetCloudFrontOriginAccessIdentityConfig2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetCloudFrontOriginAccessIdentityConfig2020_05_31, request, handler, context);
  }
 
  virtual Model::GetConnectionFunction2020_05_31Outcome GetConnectionFunction2020_05_31(
      const Model::GetConnectionFunction2020_05_31Request& request) const;
 
  template <typename GetConnectionFunction2020_05_31RequestT = Model::GetConnectionFunction2020_05_31Request>
  Model::GetConnectionFunction2020_05_31OutcomeCallable GetConnectionFunction2020_05_31Callable(
      const GetConnectionFunction2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetConnectionFunction2020_05_31, request);
  }
 
  template <typename GetConnectionFunction2020_05_31RequestT = Model::GetConnectionFunction2020_05_31Request>
  void GetConnectionFunction2020_05_31Async(const GetConnectionFunction2020_05_31RequestT& request,
                                            const GetConnectionFunction2020_05_31ResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetConnectionFunction2020_05_31, request, handler, context);
  }
 
  virtual Model::GetConnectionGroup2020_05_31Outcome GetConnectionGroup2020_05_31(
      const Model::GetConnectionGroup2020_05_31Request& request) const;
 
  template <typename GetConnectionGroup2020_05_31RequestT = Model::GetConnectionGroup2020_05_31Request>
  Model::GetConnectionGroup2020_05_31OutcomeCallable GetConnectionGroup2020_05_31Callable(
      const GetConnectionGroup2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetConnectionGroup2020_05_31, request);
  }
 
  template <typename GetConnectionGroup2020_05_31RequestT = Model::GetConnectionGroup2020_05_31Request>
  void GetConnectionGroup2020_05_31Async(const GetConnectionGroup2020_05_31RequestT& request,
                                         const GetConnectionGroup2020_05_31ResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetConnectionGroup2020_05_31, request, handler, context);
  }
 
  virtual Model::GetConnectionGroupByRoutingEndpoint2020_05_31Outcome GetConnectionGroupByRoutingEndpoint2020_05_31(
      const Model::GetConnectionGroupByRoutingEndpoint2020_05_31Request& request) const;
 
  template <typename GetConnectionGroupByRoutingEndpoint2020_05_31RequestT = Model::GetConnectionGroupByRoutingEndpoint2020_05_31Request>
  Model::GetConnectionGroupByRoutingEndpoint2020_05_31OutcomeCallable GetConnectionGroupByRoutingEndpoint2020_05_31Callable(
      const GetConnectionGroupByRoutingEndpoint2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetConnectionGroupByRoutingEndpoint2020_05_31, request);
  }
 
  template <typename GetConnectionGroupByRoutingEndpoint2020_05_31RequestT = Model::GetConnectionGroupByRoutingEndpoint2020_05_31Request>
  void GetConnectionGroupByRoutingEndpoint2020_05_31Async(
      const GetConnectionGroupByRoutingEndpoint2020_05_31RequestT& request,
      const GetConnectionGroupByRoutingEndpoint2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetConnectionGroupByRoutingEndpoint2020_05_31, request, handler, context);
  }
 
  virtual Model::GetContinuousDeploymentPolicy2020_05_31Outcome GetContinuousDeploymentPolicy2020_05_31(
      const Model::GetContinuousDeploymentPolicy2020_05_31Request& request) const;
 
  template <typename GetContinuousDeploymentPolicy2020_05_31RequestT = Model::GetContinuousDeploymentPolicy2020_05_31Request>
  Model::GetContinuousDeploymentPolicy2020_05_31OutcomeCallable GetContinuousDeploymentPolicy2020_05_31Callable(
      const GetContinuousDeploymentPolicy2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetContinuousDeploymentPolicy2020_05_31, request);
  }
 
  template <typename GetContinuousDeploymentPolicy2020_05_31RequestT = Model::GetContinuousDeploymentPolicy2020_05_31Request>
  void GetContinuousDeploymentPolicy2020_05_31Async(const GetContinuousDeploymentPolicy2020_05_31RequestT& request,
                                                    const GetContinuousDeploymentPolicy2020_05_31ResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetContinuousDeploymentPolicy2020_05_31, request, handler, context);
  }
 
  virtual Model::GetContinuousDeploymentPolicyConfig2020_05_31Outcome GetContinuousDeploymentPolicyConfig2020_05_31(
      const Model::GetContinuousDeploymentPolicyConfig2020_05_31Request& request) const;
 
  template <typename GetContinuousDeploymentPolicyConfig2020_05_31RequestT = Model::GetContinuousDeploymentPolicyConfig2020_05_31Request>
  Model::GetContinuousDeploymentPolicyConfig2020_05_31OutcomeCallable GetContinuousDeploymentPolicyConfig2020_05_31Callable(
      const GetContinuousDeploymentPolicyConfig2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetContinuousDeploymentPolicyConfig2020_05_31, request);
  }
 
  template <typename GetContinuousDeploymentPolicyConfig2020_05_31RequestT = Model::GetContinuousDeploymentPolicyConfig2020_05_31Request>
  void GetContinuousDeploymentPolicyConfig2020_05_31Async(
      const GetContinuousDeploymentPolicyConfig2020_05_31RequestT& request,
      const GetContinuousDeploymentPolicyConfig2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetContinuousDeploymentPolicyConfig2020_05_31, request, handler, context);
  }
 
  virtual Model::GetDistribution2020_05_31Outcome GetDistribution2020_05_31(const Model::GetDistribution2020_05_31Request& request) const;
 
  template <typename GetDistribution2020_05_31RequestT = Model::GetDistribution2020_05_31Request>
  Model::GetDistribution2020_05_31OutcomeCallable GetDistribution2020_05_31Callable(
      const GetDistribution2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetDistribution2020_05_31, request);
  }
 
  template <typename GetDistribution2020_05_31RequestT = Model::GetDistribution2020_05_31Request>
  void GetDistribution2020_05_31Async(const GetDistribution2020_05_31RequestT& request,
                                      const GetDistribution2020_05_31ResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetDistribution2020_05_31, request, handler, context);
  }
 
  virtual Model::GetDistributionConfig2020_05_31Outcome GetDistributionConfig2020_05_31(
      const Model::GetDistributionConfig2020_05_31Request& request) const;
 
  template <typename GetDistributionConfig2020_05_31RequestT = Model::GetDistributionConfig2020_05_31Request>
  Model::GetDistributionConfig2020_05_31OutcomeCallable GetDistributionConfig2020_05_31Callable(
      const GetDistributionConfig2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetDistributionConfig2020_05_31, request);
  }
 
  template <typename GetDistributionConfig2020_05_31RequestT = Model::GetDistributionConfig2020_05_31Request>
  void GetDistributionConfig2020_05_31Async(const GetDistributionConfig2020_05_31RequestT& request,
                                            const GetDistributionConfig2020_05_31ResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetDistributionConfig2020_05_31, request, handler, context);
  }
 
  virtual Model::GetDistributionTenant2020_05_31Outcome GetDistributionTenant2020_05_31(
      const Model::GetDistributionTenant2020_05_31Request& request) const;
 
  template <typename GetDistributionTenant2020_05_31RequestT = Model::GetDistributionTenant2020_05_31Request>
  Model::GetDistributionTenant2020_05_31OutcomeCallable GetDistributionTenant2020_05_31Callable(
      const GetDistributionTenant2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetDistributionTenant2020_05_31, request);
  }
 
  template <typename GetDistributionTenant2020_05_31RequestT = Model::GetDistributionTenant2020_05_31Request>
  void GetDistributionTenant2020_05_31Async(const GetDistributionTenant2020_05_31RequestT& request,
                                            const GetDistributionTenant2020_05_31ResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetDistributionTenant2020_05_31, request, handler, context);
  }
 
  virtual Model::GetDistributionTenantByDomain2020_05_31Outcome GetDistributionTenantByDomain2020_05_31(
      const Model::GetDistributionTenantByDomain2020_05_31Request& request) const;
 
  template <typename GetDistributionTenantByDomain2020_05_31RequestT = Model::GetDistributionTenantByDomain2020_05_31Request>
  Model::GetDistributionTenantByDomain2020_05_31OutcomeCallable GetDistributionTenantByDomain2020_05_31Callable(
      const GetDistributionTenantByDomain2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetDistributionTenantByDomain2020_05_31, request);
  }
 
  template <typename GetDistributionTenantByDomain2020_05_31RequestT = Model::GetDistributionTenantByDomain2020_05_31Request>
  void GetDistributionTenantByDomain2020_05_31Async(const GetDistributionTenantByDomain2020_05_31RequestT& request,
                                                    const GetDistributionTenantByDomain2020_05_31ResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetDistributionTenantByDomain2020_05_31, request, handler, context);
  }
 
  virtual Model::GetFieldLevelEncryption2020_05_31Outcome GetFieldLevelEncryption2020_05_31(
      const Model::GetFieldLevelEncryption2020_05_31Request& request) const;
 
  template <typename GetFieldLevelEncryption2020_05_31RequestT = Model::GetFieldLevelEncryption2020_05_31Request>
  Model::GetFieldLevelEncryption2020_05_31OutcomeCallable GetFieldLevelEncryption2020_05_31Callable(
      const GetFieldLevelEncryption2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetFieldLevelEncryption2020_05_31, request);
  }
 
  template <typename GetFieldLevelEncryption2020_05_31RequestT = Model::GetFieldLevelEncryption2020_05_31Request>
  void GetFieldLevelEncryption2020_05_31Async(const GetFieldLevelEncryption2020_05_31RequestT& request,
                                              const GetFieldLevelEncryption2020_05_31ResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetFieldLevelEncryption2020_05_31, request, handler, context);
  }
 
  virtual Model::GetFieldLevelEncryptionConfig2020_05_31Outcome GetFieldLevelEncryptionConfig2020_05_31(
      const Model::GetFieldLevelEncryptionConfig2020_05_31Request& request) const;
 
  template <typename GetFieldLevelEncryptionConfig2020_05_31RequestT = Model::GetFieldLevelEncryptionConfig2020_05_31Request>
  Model::GetFieldLevelEncryptionConfig2020_05_31OutcomeCallable GetFieldLevelEncryptionConfig2020_05_31Callable(
      const GetFieldLevelEncryptionConfig2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetFieldLevelEncryptionConfig2020_05_31, request);
  }
 
  template <typename GetFieldLevelEncryptionConfig2020_05_31RequestT = Model::GetFieldLevelEncryptionConfig2020_05_31Request>
  void GetFieldLevelEncryptionConfig2020_05_31Async(const GetFieldLevelEncryptionConfig2020_05_31RequestT& request,
                                                    const GetFieldLevelEncryptionConfig2020_05_31ResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetFieldLevelEncryptionConfig2020_05_31, request, handler, context);
  }
 
  virtual Model::GetFieldLevelEncryptionProfile2020_05_31Outcome GetFieldLevelEncryptionProfile2020_05_31(
      const Model::GetFieldLevelEncryptionProfile2020_05_31Request& request) const;
 
  template <typename GetFieldLevelEncryptionProfile2020_05_31RequestT = Model::GetFieldLevelEncryptionProfile2020_05_31Request>
  Model::GetFieldLevelEncryptionProfile2020_05_31OutcomeCallable GetFieldLevelEncryptionProfile2020_05_31Callable(
      const GetFieldLevelEncryptionProfile2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetFieldLevelEncryptionProfile2020_05_31, request);
  }
 
  template <typename GetFieldLevelEncryptionProfile2020_05_31RequestT = Model::GetFieldLevelEncryptionProfile2020_05_31Request>
  void GetFieldLevelEncryptionProfile2020_05_31Async(
      const GetFieldLevelEncryptionProfile2020_05_31RequestT& request,
      const GetFieldLevelEncryptionProfile2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetFieldLevelEncryptionProfile2020_05_31, request, handler, context);
  }
 
  virtual Model::GetFieldLevelEncryptionProfileConfig2020_05_31Outcome GetFieldLevelEncryptionProfileConfig2020_05_31(
      const Model::GetFieldLevelEncryptionProfileConfig2020_05_31Request& request) const;
 
  template <typename GetFieldLevelEncryptionProfileConfig2020_05_31RequestT = Model::GetFieldLevelEncryptionProfileConfig2020_05_31Request>
  Model::GetFieldLevelEncryptionProfileConfig2020_05_31OutcomeCallable GetFieldLevelEncryptionProfileConfig2020_05_31Callable(
      const GetFieldLevelEncryptionProfileConfig2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetFieldLevelEncryptionProfileConfig2020_05_31, request);
  }
 
  template <typename GetFieldLevelEncryptionProfileConfig2020_05_31RequestT = Model::GetFieldLevelEncryptionProfileConfig2020_05_31Request>
  void GetFieldLevelEncryptionProfileConfig2020_05_31Async(
      const GetFieldLevelEncryptionProfileConfig2020_05_31RequestT& request,
      const GetFieldLevelEncryptionProfileConfig2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetFieldLevelEncryptionProfileConfig2020_05_31, request, handler, context);
  }
 
  virtual Model::GetFunction2020_05_31Outcome GetFunction2020_05_31(const Model::GetFunction2020_05_31Request& request) const;
 
  template <typename GetFunction2020_05_31RequestT = Model::GetFunction2020_05_31Request>
  Model::GetFunction2020_05_31OutcomeCallable GetFunction2020_05_31Callable(const GetFunction2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetFunction2020_05_31, request);
  }
 
  template <typename GetFunction2020_05_31RequestT = Model::GetFunction2020_05_31Request>
  void GetFunction2020_05_31Async(const GetFunction2020_05_31RequestT& request, const GetFunction2020_05_31ResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetFunction2020_05_31, request, handler, context);
  }
 
  virtual Model::GetInvalidation2020_05_31Outcome GetInvalidation2020_05_31(const Model::GetInvalidation2020_05_31Request& request) const;
 
  template <typename GetInvalidation2020_05_31RequestT = Model::GetInvalidation2020_05_31Request>
  Model::GetInvalidation2020_05_31OutcomeCallable GetInvalidation2020_05_31Callable(
      const GetInvalidation2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetInvalidation2020_05_31, request);
  }
 
  template <typename GetInvalidation2020_05_31RequestT = Model::GetInvalidation2020_05_31Request>
  void GetInvalidation2020_05_31Async(const GetInvalidation2020_05_31RequestT& request,
                                      const GetInvalidation2020_05_31ResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetInvalidation2020_05_31, request, handler, context);
  }
 
  virtual Model::GetInvalidationForDistributionTenant2020_05_31Outcome GetInvalidationForDistributionTenant2020_05_31(
      const Model::GetInvalidationForDistributionTenant2020_05_31Request& request) const;
 
  template <typename GetInvalidationForDistributionTenant2020_05_31RequestT = Model::GetInvalidationForDistributionTenant2020_05_31Request>
  Model::GetInvalidationForDistributionTenant2020_05_31OutcomeCallable GetInvalidationForDistributionTenant2020_05_31Callable(
      const GetInvalidationForDistributionTenant2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetInvalidationForDistributionTenant2020_05_31, request);
  }
 
  template <typename GetInvalidationForDistributionTenant2020_05_31RequestT = Model::GetInvalidationForDistributionTenant2020_05_31Request>
  void GetInvalidationForDistributionTenant2020_05_31Async(
      const GetInvalidationForDistributionTenant2020_05_31RequestT& request,
      const GetInvalidationForDistributionTenant2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetInvalidationForDistributionTenant2020_05_31, request, handler, context);
  }
 
  virtual Model::GetKeyGroup2020_05_31Outcome GetKeyGroup2020_05_31(const Model::GetKeyGroup2020_05_31Request& request) const;
 
  template <typename GetKeyGroup2020_05_31RequestT = Model::GetKeyGroup2020_05_31Request>
  Model::GetKeyGroup2020_05_31OutcomeCallable GetKeyGroup2020_05_31Callable(const GetKeyGroup2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetKeyGroup2020_05_31, request);
  }
 
  template <typename GetKeyGroup2020_05_31RequestT = Model::GetKeyGroup2020_05_31Request>
  void GetKeyGroup2020_05_31Async(const GetKeyGroup2020_05_31RequestT& request, const GetKeyGroup2020_05_31ResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetKeyGroup2020_05_31, request, handler, context);
  }
 
  virtual Model::GetKeyGroupConfig2020_05_31Outcome GetKeyGroupConfig2020_05_31(
      const Model::GetKeyGroupConfig2020_05_31Request& request) const;
 
  template <typename GetKeyGroupConfig2020_05_31RequestT = Model::GetKeyGroupConfig2020_05_31Request>
  Model::GetKeyGroupConfig2020_05_31OutcomeCallable GetKeyGroupConfig2020_05_31Callable(
      const GetKeyGroupConfig2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetKeyGroupConfig2020_05_31, request);
  }
 
  template <typename GetKeyGroupConfig2020_05_31RequestT = Model::GetKeyGroupConfig2020_05_31Request>
  void GetKeyGroupConfig2020_05_31Async(const GetKeyGroupConfig2020_05_31RequestT& request,
                                        const GetKeyGroupConfig2020_05_31ResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetKeyGroupConfig2020_05_31, request, handler, context);
  }
 
  virtual Model::GetManagedCertificateDetails2020_05_31Outcome GetManagedCertificateDetails2020_05_31(
      const Model::GetManagedCertificateDetails2020_05_31Request& request) const;
 
  template <typename GetManagedCertificateDetails2020_05_31RequestT = Model::GetManagedCertificateDetails2020_05_31Request>
  Model::GetManagedCertificateDetails2020_05_31OutcomeCallable GetManagedCertificateDetails2020_05_31Callable(
      const GetManagedCertificateDetails2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetManagedCertificateDetails2020_05_31, request);
  }
 
  template <typename GetManagedCertificateDetails2020_05_31RequestT = Model::GetManagedCertificateDetails2020_05_31Request>
  void GetManagedCertificateDetails2020_05_31Async(const GetManagedCertificateDetails2020_05_31RequestT& request,
                                                   const GetManagedCertificateDetails2020_05_31ResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetManagedCertificateDetails2020_05_31, request, handler, context);
  }
 
  virtual Model::GetMonitoringSubscription2020_05_31Outcome GetMonitoringSubscription2020_05_31(
      const Model::GetMonitoringSubscription2020_05_31Request& request) const;
 
  template <typename GetMonitoringSubscription2020_05_31RequestT = Model::GetMonitoringSubscription2020_05_31Request>
  Model::GetMonitoringSubscription2020_05_31OutcomeCallable GetMonitoringSubscription2020_05_31Callable(
      const GetMonitoringSubscription2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetMonitoringSubscription2020_05_31, request);
  }
 
  template <typename GetMonitoringSubscription2020_05_31RequestT = Model::GetMonitoringSubscription2020_05_31Request>
  void GetMonitoringSubscription2020_05_31Async(const GetMonitoringSubscription2020_05_31RequestT& request,
                                                const GetMonitoringSubscription2020_05_31ResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetMonitoringSubscription2020_05_31, request, handler, context);
  }
 
  virtual Model::GetOriginAccessControl2020_05_31Outcome GetOriginAccessControl2020_05_31(
      const Model::GetOriginAccessControl2020_05_31Request& request) const;
 
  template <typename GetOriginAccessControl2020_05_31RequestT = Model::GetOriginAccessControl2020_05_31Request>
  Model::GetOriginAccessControl2020_05_31OutcomeCallable GetOriginAccessControl2020_05_31Callable(
      const GetOriginAccessControl2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetOriginAccessControl2020_05_31, request);
  }
 
  template <typename GetOriginAccessControl2020_05_31RequestT = Model::GetOriginAccessControl2020_05_31Request>
  void GetOriginAccessControl2020_05_31Async(const GetOriginAccessControl2020_05_31RequestT& request,
                                             const GetOriginAccessControl2020_05_31ResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetOriginAccessControl2020_05_31, request, handler, context);
  }
 
  virtual Model::GetOriginAccessControlConfig2020_05_31Outcome GetOriginAccessControlConfig2020_05_31(
      const Model::GetOriginAccessControlConfig2020_05_31Request& request) const;
 
  template <typename GetOriginAccessControlConfig2020_05_31RequestT = Model::GetOriginAccessControlConfig2020_05_31Request>
  Model::GetOriginAccessControlConfig2020_05_31OutcomeCallable GetOriginAccessControlConfig2020_05_31Callable(
      const GetOriginAccessControlConfig2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetOriginAccessControlConfig2020_05_31, request);
  }
 
  template <typename GetOriginAccessControlConfig2020_05_31RequestT = Model::GetOriginAccessControlConfig2020_05_31Request>
  void GetOriginAccessControlConfig2020_05_31Async(const GetOriginAccessControlConfig2020_05_31RequestT& request,
                                                   const GetOriginAccessControlConfig2020_05_31ResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetOriginAccessControlConfig2020_05_31, request, handler, context);
  }
 
  virtual Model::GetOriginRequestPolicy2020_05_31Outcome GetOriginRequestPolicy2020_05_31(
      const Model::GetOriginRequestPolicy2020_05_31Request& request) const;
 
  template <typename GetOriginRequestPolicy2020_05_31RequestT = Model::GetOriginRequestPolicy2020_05_31Request>
  Model::GetOriginRequestPolicy2020_05_31OutcomeCallable GetOriginRequestPolicy2020_05_31Callable(
      const GetOriginRequestPolicy2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetOriginRequestPolicy2020_05_31, request);
  }
 
  template <typename GetOriginRequestPolicy2020_05_31RequestT = Model::GetOriginRequestPolicy2020_05_31Request>
  void GetOriginRequestPolicy2020_05_31Async(const GetOriginRequestPolicy2020_05_31RequestT& request,
                                             const GetOriginRequestPolicy2020_05_31ResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetOriginRequestPolicy2020_05_31, request, handler, context);
  }
 
  virtual Model::GetOriginRequestPolicyConfig2020_05_31Outcome GetOriginRequestPolicyConfig2020_05_31(
      const Model::GetOriginRequestPolicyConfig2020_05_31Request& request) const;
 
  template <typename GetOriginRequestPolicyConfig2020_05_31RequestT = Model::GetOriginRequestPolicyConfig2020_05_31Request>
  Model::GetOriginRequestPolicyConfig2020_05_31OutcomeCallable GetOriginRequestPolicyConfig2020_05_31Callable(
      const GetOriginRequestPolicyConfig2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetOriginRequestPolicyConfig2020_05_31, request);
  }
 
  template <typename GetOriginRequestPolicyConfig2020_05_31RequestT = Model::GetOriginRequestPolicyConfig2020_05_31Request>
  void GetOriginRequestPolicyConfig2020_05_31Async(const GetOriginRequestPolicyConfig2020_05_31RequestT& request,
                                                   const GetOriginRequestPolicyConfig2020_05_31ResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetOriginRequestPolicyConfig2020_05_31, request, handler, context);
  }
 
  virtual Model::GetPublicKey2020_05_31Outcome GetPublicKey2020_05_31(const Model::GetPublicKey2020_05_31Request& request) const;
 
  template <typename GetPublicKey2020_05_31RequestT = Model::GetPublicKey2020_05_31Request>
  Model::GetPublicKey2020_05_31OutcomeCallable GetPublicKey2020_05_31Callable(const GetPublicKey2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetPublicKey2020_05_31, request);
  }
 
  template <typename GetPublicKey2020_05_31RequestT = Model::GetPublicKey2020_05_31Request>
  void GetPublicKey2020_05_31Async(const GetPublicKey2020_05_31RequestT& request,
                                   const GetPublicKey2020_05_31ResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetPublicKey2020_05_31, request, handler, context);
  }
 
  virtual Model::GetPublicKeyConfig2020_05_31Outcome GetPublicKeyConfig2020_05_31(
      const Model::GetPublicKeyConfig2020_05_31Request& request) const;
 
  template <typename GetPublicKeyConfig2020_05_31RequestT = Model::GetPublicKeyConfig2020_05_31Request>
  Model::GetPublicKeyConfig2020_05_31OutcomeCallable GetPublicKeyConfig2020_05_31Callable(
      const GetPublicKeyConfig2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetPublicKeyConfig2020_05_31, request);
  }
 
  template <typename GetPublicKeyConfig2020_05_31RequestT = Model::GetPublicKeyConfig2020_05_31Request>
  void GetPublicKeyConfig2020_05_31Async(const GetPublicKeyConfig2020_05_31RequestT& request,
                                         const GetPublicKeyConfig2020_05_31ResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetPublicKeyConfig2020_05_31, request, handler, context);
  }
 
  virtual Model::GetRealtimeLogConfig2020_05_31Outcome GetRealtimeLogConfig2020_05_31(
      const Model::GetRealtimeLogConfig2020_05_31Request& request = {}) const;
 
  template <typename GetRealtimeLogConfig2020_05_31RequestT = Model::GetRealtimeLogConfig2020_05_31Request>
  Model::GetRealtimeLogConfig2020_05_31OutcomeCallable GetRealtimeLogConfig2020_05_31Callable(
      const GetRealtimeLogConfig2020_05_31RequestT& request = {}) const {
    return SubmitCallable(&CloudFrontClient::GetRealtimeLogConfig2020_05_31, request);
  }
 
  template <typename GetRealtimeLogConfig2020_05_31RequestT = Model::GetRealtimeLogConfig2020_05_31Request>
  void GetRealtimeLogConfig2020_05_31Async(const GetRealtimeLogConfig2020_05_31ResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const GetRealtimeLogConfig2020_05_31RequestT& request = {}) const {
    return SubmitAsync(&CloudFrontClient::GetRealtimeLogConfig2020_05_31, request, handler, context);
  }
 
  virtual Model::GetResourcePolicy2020_05_31Outcome GetResourcePolicy2020_05_31(
      const Model::GetResourcePolicy2020_05_31Request& request) const;
 
  template <typename GetResourcePolicy2020_05_31RequestT = Model::GetResourcePolicy2020_05_31Request>
  Model::GetResourcePolicy2020_05_31OutcomeCallable GetResourcePolicy2020_05_31Callable(
      const GetResourcePolicy2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetResourcePolicy2020_05_31, request);
  }
 
  template <typename GetResourcePolicy2020_05_31RequestT = Model::GetResourcePolicy2020_05_31Request>
  void GetResourcePolicy2020_05_31Async(const GetResourcePolicy2020_05_31RequestT& request,
                                        const GetResourcePolicy2020_05_31ResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetResourcePolicy2020_05_31, request, handler, context);
  }
 
  virtual Model::GetResponseHeadersPolicy2020_05_31Outcome GetResponseHeadersPolicy2020_05_31(
      const Model::GetResponseHeadersPolicy2020_05_31Request& request) const;
 
  template <typename GetResponseHeadersPolicy2020_05_31RequestT = Model::GetResponseHeadersPolicy2020_05_31Request>
  Model::GetResponseHeadersPolicy2020_05_31OutcomeCallable GetResponseHeadersPolicy2020_05_31Callable(
      const GetResponseHeadersPolicy2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetResponseHeadersPolicy2020_05_31, request);
  }
 
  template <typename GetResponseHeadersPolicy2020_05_31RequestT = Model::GetResponseHeadersPolicy2020_05_31Request>
  void GetResponseHeadersPolicy2020_05_31Async(const GetResponseHeadersPolicy2020_05_31RequestT& request,
                                               const GetResponseHeadersPolicy2020_05_31ResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetResponseHeadersPolicy2020_05_31, request, handler, context);
  }
 
  virtual Model::GetResponseHeadersPolicyConfig2020_05_31Outcome GetResponseHeadersPolicyConfig2020_05_31(
      const Model::GetResponseHeadersPolicyConfig2020_05_31Request& request) const;
 
  template <typename GetResponseHeadersPolicyConfig2020_05_31RequestT = Model::GetResponseHeadersPolicyConfig2020_05_31Request>
  Model::GetResponseHeadersPolicyConfig2020_05_31OutcomeCallable GetResponseHeadersPolicyConfig2020_05_31Callable(
      const GetResponseHeadersPolicyConfig2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetResponseHeadersPolicyConfig2020_05_31, request);
  }
 
  template <typename GetResponseHeadersPolicyConfig2020_05_31RequestT = Model::GetResponseHeadersPolicyConfig2020_05_31Request>
  void GetResponseHeadersPolicyConfig2020_05_31Async(
      const GetResponseHeadersPolicyConfig2020_05_31RequestT& request,
      const GetResponseHeadersPolicyConfig2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetResponseHeadersPolicyConfig2020_05_31, request, handler, context);
  }
 
  virtual Model::GetStreamingDistribution2020_05_31Outcome GetStreamingDistribution2020_05_31(
      const Model::GetStreamingDistribution2020_05_31Request& request) const;
 
  template <typename GetStreamingDistribution2020_05_31RequestT = Model::GetStreamingDistribution2020_05_31Request>
  Model::GetStreamingDistribution2020_05_31OutcomeCallable GetStreamingDistribution2020_05_31Callable(
      const GetStreamingDistribution2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetStreamingDistribution2020_05_31, request);
  }
 
  template <typename GetStreamingDistribution2020_05_31RequestT = Model::GetStreamingDistribution2020_05_31Request>
  void GetStreamingDistribution2020_05_31Async(const GetStreamingDistribution2020_05_31RequestT& request,
                                               const GetStreamingDistribution2020_05_31ResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetStreamingDistribution2020_05_31, request, handler, context);
  }
 
  virtual Model::GetStreamingDistributionConfig2020_05_31Outcome GetStreamingDistributionConfig2020_05_31(
      const Model::GetStreamingDistributionConfig2020_05_31Request& request) const;
 
  template <typename GetStreamingDistributionConfig2020_05_31RequestT = Model::GetStreamingDistributionConfig2020_05_31Request>
  Model::GetStreamingDistributionConfig2020_05_31OutcomeCallable GetStreamingDistributionConfig2020_05_31Callable(
      const GetStreamingDistributionConfig2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetStreamingDistributionConfig2020_05_31, request);
  }
 
  template <typename GetStreamingDistributionConfig2020_05_31RequestT = Model::GetStreamingDistributionConfig2020_05_31Request>
  void GetStreamingDistributionConfig2020_05_31Async(
      const GetStreamingDistributionConfig2020_05_31RequestT& request,
      const GetStreamingDistributionConfig2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetStreamingDistributionConfig2020_05_31, request, handler, context);
  }
 
  virtual Model::GetTrustStore2020_05_31Outcome GetTrustStore2020_05_31(const Model::GetTrustStore2020_05_31Request& request) const;
 
  template <typename GetTrustStore2020_05_31RequestT = Model::GetTrustStore2020_05_31Request>
  Model::GetTrustStore2020_05_31OutcomeCallable GetTrustStore2020_05_31Callable(const GetTrustStore2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetTrustStore2020_05_31, request);
  }
 
  template <typename GetTrustStore2020_05_31RequestT = Model::GetTrustStore2020_05_31Request>
  void GetTrustStore2020_05_31Async(const GetTrustStore2020_05_31RequestT& request,
                                    const GetTrustStore2020_05_31ResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetTrustStore2020_05_31, request, handler, context);
  }
 
  virtual Model::GetVpcOrigin2020_05_31Outcome GetVpcOrigin2020_05_31(const Model::GetVpcOrigin2020_05_31Request& request) const;
 
  template <typename GetVpcOrigin2020_05_31RequestT = Model::GetVpcOrigin2020_05_31Request>
  Model::GetVpcOrigin2020_05_31OutcomeCallable GetVpcOrigin2020_05_31Callable(const GetVpcOrigin2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::GetVpcOrigin2020_05_31, request);
  }
 
  template <typename GetVpcOrigin2020_05_31RequestT = Model::GetVpcOrigin2020_05_31Request>
  void GetVpcOrigin2020_05_31Async(const GetVpcOrigin2020_05_31RequestT& request,
                                   const GetVpcOrigin2020_05_31ResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::GetVpcOrigin2020_05_31, request, handler, context);
  }
 
  virtual Model::ListAnycastIpLists2020_05_31Outcome ListAnycastIpLists2020_05_31(
      const Model::ListAnycastIpLists2020_05_31Request& request = {}) const;
 
  template <typename ListAnycastIpLists2020_05_31RequestT = Model::ListAnycastIpLists2020_05_31Request>
  Model::ListAnycastIpLists2020_05_31OutcomeCallable ListAnycastIpLists2020_05_31Callable(
      const ListAnycastIpLists2020_05_31RequestT& request = {}) const {
    return SubmitCallable(&CloudFrontClient::ListAnycastIpLists2020_05_31, request);
  }
 
  template <typename ListAnycastIpLists2020_05_31RequestT = Model::ListAnycastIpLists2020_05_31Request>
  void ListAnycastIpLists2020_05_31Async(const ListAnycastIpLists2020_05_31ResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const ListAnycastIpLists2020_05_31RequestT& request = {}) const {
    return SubmitAsync(&CloudFrontClient::ListAnycastIpLists2020_05_31, request, handler, context);
  }
 
  virtual Model::ListCachePolicies2020_05_31Outcome ListCachePolicies2020_05_31(
      const Model::ListCachePolicies2020_05_31Request& request = {}) const;
 
  template <typename ListCachePolicies2020_05_31RequestT = Model::ListCachePolicies2020_05_31Request>
  Model::ListCachePolicies2020_05_31OutcomeCallable ListCachePolicies2020_05_31Callable(
      const ListCachePolicies2020_05_31RequestT& request = {}) const {
    return SubmitCallable(&CloudFrontClient::ListCachePolicies2020_05_31, request);
  }
 
  template <typename ListCachePolicies2020_05_31RequestT = Model::ListCachePolicies2020_05_31Request>
  void ListCachePolicies2020_05_31Async(const ListCachePolicies2020_05_31ResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const ListCachePolicies2020_05_31RequestT& request = {}) const {
    return SubmitAsync(&CloudFrontClient::ListCachePolicies2020_05_31, request, handler, context);
  }
 
  virtual Model::ListCloudFrontOriginAccessIdentities2020_05_31Outcome ListCloudFrontOriginAccessIdentities2020_05_31(
      const Model::ListCloudFrontOriginAccessIdentities2020_05_31Request& request = {}) const;
 
  template <typename ListCloudFrontOriginAccessIdentities2020_05_31RequestT = Model::ListCloudFrontOriginAccessIdentities2020_05_31Request>
  Model::ListCloudFrontOriginAccessIdentities2020_05_31OutcomeCallable ListCloudFrontOriginAccessIdentities2020_05_31Callable(
      const ListCloudFrontOriginAccessIdentities2020_05_31RequestT& request = {}) const {
    return SubmitCallable(&CloudFrontClient::ListCloudFrontOriginAccessIdentities2020_05_31, request);
  }
 
  template <typename ListCloudFrontOriginAccessIdentities2020_05_31RequestT = Model::ListCloudFrontOriginAccessIdentities2020_05_31Request>
  void ListCloudFrontOriginAccessIdentities2020_05_31Async(
      const ListCloudFrontOriginAccessIdentities2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
      const ListCloudFrontOriginAccessIdentities2020_05_31RequestT& request = {}) const {
    return SubmitAsync(&CloudFrontClient::ListCloudFrontOriginAccessIdentities2020_05_31, request, handler, context);
  }
 
  virtual Model::ListConflictingAliases2020_05_31Outcome ListConflictingAliases2020_05_31(
      const Model::ListConflictingAliases2020_05_31Request& request) const;
 
  template <typename ListConflictingAliases2020_05_31RequestT = Model::ListConflictingAliases2020_05_31Request>
  Model::ListConflictingAliases2020_05_31OutcomeCallable ListConflictingAliases2020_05_31Callable(
      const ListConflictingAliases2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::ListConflictingAliases2020_05_31, request);
  }
 
  template <typename ListConflictingAliases2020_05_31RequestT = Model::ListConflictingAliases2020_05_31Request>
  void ListConflictingAliases2020_05_31Async(const ListConflictingAliases2020_05_31RequestT& request,
                                             const ListConflictingAliases2020_05_31ResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::ListConflictingAliases2020_05_31, request, handler, context);
  }
 
  virtual Model::ListConnectionFunctions2020_05_31Outcome ListConnectionFunctions2020_05_31(
      const Model::ListConnectionFunctions2020_05_31Request& request = {}) const;
 
  template <typename ListConnectionFunctions2020_05_31RequestT = Model::ListConnectionFunctions2020_05_31Request>
  Model::ListConnectionFunctions2020_05_31OutcomeCallable ListConnectionFunctions2020_05_31Callable(
      const ListConnectionFunctions2020_05_31RequestT& request = {}) const {
    return SubmitCallable(&CloudFrontClient::ListConnectionFunctions2020_05_31, request);
  }
 
  template <typename ListConnectionFunctions2020_05_31RequestT = Model::ListConnectionFunctions2020_05_31Request>
  void ListConnectionFunctions2020_05_31Async(const ListConnectionFunctions2020_05_31ResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const ListConnectionFunctions2020_05_31RequestT& request = {}) const {
    return SubmitAsync(&CloudFrontClient::ListConnectionFunctions2020_05_31, request, handler, context);
  }
 
  virtual Model::ListConnectionGroups2020_05_31Outcome ListConnectionGroups2020_05_31(
      const Model::ListConnectionGroups2020_05_31Request& request = {}) const;
 
  template <typename ListConnectionGroups2020_05_31RequestT = Model::ListConnectionGroups2020_05_31Request>
  Model::ListConnectionGroups2020_05_31OutcomeCallable ListConnectionGroups2020_05_31Callable(
      const ListConnectionGroups2020_05_31RequestT& request = {}) const {
    return SubmitCallable(&CloudFrontClient::ListConnectionGroups2020_05_31, request);
  }
 
  template <typename ListConnectionGroups2020_05_31RequestT = Model::ListConnectionGroups2020_05_31Request>
  void ListConnectionGroups2020_05_31Async(const ListConnectionGroups2020_05_31ResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const ListConnectionGroups2020_05_31RequestT& request = {}) const {
    return SubmitAsync(&CloudFrontClient::ListConnectionGroups2020_05_31, request, handler, context);
  }
 
  virtual Model::ListContinuousDeploymentPolicies2020_05_31Outcome ListContinuousDeploymentPolicies2020_05_31(
      const Model::ListContinuousDeploymentPolicies2020_05_31Request& request = {}) const;
 
  template <typename ListContinuousDeploymentPolicies2020_05_31RequestT = Model::ListContinuousDeploymentPolicies2020_05_31Request>
  Model::ListContinuousDeploymentPolicies2020_05_31OutcomeCallable ListContinuousDeploymentPolicies2020_05_31Callable(
      const ListContinuousDeploymentPolicies2020_05_31RequestT& request = {}) const {
    return SubmitCallable(&CloudFrontClient::ListContinuousDeploymentPolicies2020_05_31, request);
  }
 
  template <typename ListContinuousDeploymentPolicies2020_05_31RequestT = Model::ListContinuousDeploymentPolicies2020_05_31Request>
  void ListContinuousDeploymentPolicies2020_05_31Async(const ListContinuousDeploymentPolicies2020_05_31ResponseReceivedHandler& handler,
                                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                       const ListContinuousDeploymentPolicies2020_05_31RequestT& request = {}) const {
    return SubmitAsync(&CloudFrontClient::ListContinuousDeploymentPolicies2020_05_31, request, handler, context);
  }
 
  virtual Model::ListDistributionTenants2020_05_31Outcome ListDistributionTenants2020_05_31(
      const Model::ListDistributionTenants2020_05_31Request& request = {}) const;
 
  template <typename ListDistributionTenants2020_05_31RequestT = Model::ListDistributionTenants2020_05_31Request>
  Model::ListDistributionTenants2020_05_31OutcomeCallable ListDistributionTenants2020_05_31Callable(
      const ListDistributionTenants2020_05_31RequestT& request = {}) const {
    return SubmitCallable(&CloudFrontClient::ListDistributionTenants2020_05_31, request);
  }
 
  template <typename ListDistributionTenants2020_05_31RequestT = Model::ListDistributionTenants2020_05_31Request>
  void ListDistributionTenants2020_05_31Async(const ListDistributionTenants2020_05_31ResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const ListDistributionTenants2020_05_31RequestT& request = {}) const {
    return SubmitAsync(&CloudFrontClient::ListDistributionTenants2020_05_31, request, handler, context);
  }
 
  virtual Model::ListDistributionTenantsByCustomization2020_05_31Outcome ListDistributionTenantsByCustomization2020_05_31(
      const Model::ListDistributionTenantsByCustomization2020_05_31Request& request = {}) const;
 
  template <
      typename ListDistributionTenantsByCustomization2020_05_31RequestT = Model::ListDistributionTenantsByCustomization2020_05_31Request>
  Model::ListDistributionTenantsByCustomization2020_05_31OutcomeCallable ListDistributionTenantsByCustomization2020_05_31Callable(
      const ListDistributionTenantsByCustomization2020_05_31RequestT& request = {}) const {
    return SubmitCallable(&CloudFrontClient::ListDistributionTenantsByCustomization2020_05_31, request);
  }
 
  template <
      typename ListDistributionTenantsByCustomization2020_05_31RequestT = Model::ListDistributionTenantsByCustomization2020_05_31Request>
  void ListDistributionTenantsByCustomization2020_05_31Async(
      const ListDistributionTenantsByCustomization2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
      const ListDistributionTenantsByCustomization2020_05_31RequestT& request = {}) const {
    return SubmitAsync(&CloudFrontClient::ListDistributionTenantsByCustomization2020_05_31, request, handler, context);
  }
 
  virtual Model::ListDistributions2020_05_31Outcome ListDistributions2020_05_31(
      const Model::ListDistributions2020_05_31Request& request = {}) const;
 
  template <typename ListDistributions2020_05_31RequestT = Model::ListDistributions2020_05_31Request>
  Model::ListDistributions2020_05_31OutcomeCallable ListDistributions2020_05_31Callable(
      const ListDistributions2020_05_31RequestT& request = {}) const {
    return SubmitCallable(&CloudFrontClient::ListDistributions2020_05_31, request);
  }
 
  template <typename ListDistributions2020_05_31RequestT = Model::ListDistributions2020_05_31Request>
  void ListDistributions2020_05_31Async(const ListDistributions2020_05_31ResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const ListDistributions2020_05_31RequestT& request = {}) const {
    return SubmitAsync(&CloudFrontClient::ListDistributions2020_05_31, request, handler, context);
  }
 
  virtual Model::ListDistributionsByAnycastIpListId2020_05_31Outcome ListDistributionsByAnycastIpListId2020_05_31(
      const Model::ListDistributionsByAnycastIpListId2020_05_31Request& request) const;
 
  template <typename ListDistributionsByAnycastIpListId2020_05_31RequestT = Model::ListDistributionsByAnycastIpListId2020_05_31Request>
  Model::ListDistributionsByAnycastIpListId2020_05_31OutcomeCallable ListDistributionsByAnycastIpListId2020_05_31Callable(
      const ListDistributionsByAnycastIpListId2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::ListDistributionsByAnycastIpListId2020_05_31, request);
  }
 
  template <typename ListDistributionsByAnycastIpListId2020_05_31RequestT = Model::ListDistributionsByAnycastIpListId2020_05_31Request>
  void ListDistributionsByAnycastIpListId2020_05_31Async(
      const ListDistributionsByAnycastIpListId2020_05_31RequestT& request,
      const ListDistributionsByAnycastIpListId2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::ListDistributionsByAnycastIpListId2020_05_31, request, handler, context);
  }
 
  virtual Model::ListDistributionsByCachePolicyId2020_05_31Outcome ListDistributionsByCachePolicyId2020_05_31(
      const Model::ListDistributionsByCachePolicyId2020_05_31Request& request) const;
 
  template <typename ListDistributionsByCachePolicyId2020_05_31RequestT = Model::ListDistributionsByCachePolicyId2020_05_31Request>
  Model::ListDistributionsByCachePolicyId2020_05_31OutcomeCallable ListDistributionsByCachePolicyId2020_05_31Callable(
      const ListDistributionsByCachePolicyId2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::ListDistributionsByCachePolicyId2020_05_31, request);
  }
 
  template <typename ListDistributionsByCachePolicyId2020_05_31RequestT = Model::ListDistributionsByCachePolicyId2020_05_31Request>
  void ListDistributionsByCachePolicyId2020_05_31Async(
      const ListDistributionsByCachePolicyId2020_05_31RequestT& request,
      const ListDistributionsByCachePolicyId2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::ListDistributionsByCachePolicyId2020_05_31, request, handler, context);
  }
 
  virtual Model::ListDistributionsByConnectionFunction2020_05_31Outcome ListDistributionsByConnectionFunction2020_05_31(
      const Model::ListDistributionsByConnectionFunction2020_05_31Request& request) const;
 
  template <
      typename ListDistributionsByConnectionFunction2020_05_31RequestT = Model::ListDistributionsByConnectionFunction2020_05_31Request>
  Model::ListDistributionsByConnectionFunction2020_05_31OutcomeCallable ListDistributionsByConnectionFunction2020_05_31Callable(
      const ListDistributionsByConnectionFunction2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::ListDistributionsByConnectionFunction2020_05_31, request);
  }
 
  template <
      typename ListDistributionsByConnectionFunction2020_05_31RequestT = Model::ListDistributionsByConnectionFunction2020_05_31Request>
  void ListDistributionsByConnectionFunction2020_05_31Async(
      const ListDistributionsByConnectionFunction2020_05_31RequestT& request,
      const ListDistributionsByConnectionFunction2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::ListDistributionsByConnectionFunction2020_05_31, request, handler, context);
  }
 
  virtual Model::ListDistributionsByConnectionMode2020_05_31Outcome ListDistributionsByConnectionMode2020_05_31(
      const Model::ListDistributionsByConnectionMode2020_05_31Request& request) const;
 
  template <typename ListDistributionsByConnectionMode2020_05_31RequestT = Model::ListDistributionsByConnectionMode2020_05_31Request>
  Model::ListDistributionsByConnectionMode2020_05_31OutcomeCallable ListDistributionsByConnectionMode2020_05_31Callable(
      const ListDistributionsByConnectionMode2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::ListDistributionsByConnectionMode2020_05_31, request);
  }
 
  template <typename ListDistributionsByConnectionMode2020_05_31RequestT = Model::ListDistributionsByConnectionMode2020_05_31Request>
  void ListDistributionsByConnectionMode2020_05_31Async(
      const ListDistributionsByConnectionMode2020_05_31RequestT& request,
      const ListDistributionsByConnectionMode2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::ListDistributionsByConnectionMode2020_05_31, request, handler, context);
  }
 
  virtual Model::ListDistributionsByKeyGroup2020_05_31Outcome ListDistributionsByKeyGroup2020_05_31(
      const Model::ListDistributionsByKeyGroup2020_05_31Request& request) const;
 
  template <typename ListDistributionsByKeyGroup2020_05_31RequestT = Model::ListDistributionsByKeyGroup2020_05_31Request>
  Model::ListDistributionsByKeyGroup2020_05_31OutcomeCallable ListDistributionsByKeyGroup2020_05_31Callable(
      const ListDistributionsByKeyGroup2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::ListDistributionsByKeyGroup2020_05_31, request);
  }
 
  template <typename ListDistributionsByKeyGroup2020_05_31RequestT = Model::ListDistributionsByKeyGroup2020_05_31Request>
  void ListDistributionsByKeyGroup2020_05_31Async(const ListDistributionsByKeyGroup2020_05_31RequestT& request,
                                                  const ListDistributionsByKeyGroup2020_05_31ResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::ListDistributionsByKeyGroup2020_05_31, request, handler, context);
  }
 
  virtual Model::ListDistributionsByOriginRequestPolicyId2020_05_31Outcome ListDistributionsByOriginRequestPolicyId2020_05_31(
      const Model::ListDistributionsByOriginRequestPolicyId2020_05_31Request& request) const;
 
  template <typename ListDistributionsByOriginRequestPolicyId2020_05_31RequestT =
                Model::ListDistributionsByOriginRequestPolicyId2020_05_31Request>
  Model::ListDistributionsByOriginRequestPolicyId2020_05_31OutcomeCallable ListDistributionsByOriginRequestPolicyId2020_05_31Callable(
      const ListDistributionsByOriginRequestPolicyId2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::ListDistributionsByOriginRequestPolicyId2020_05_31, request);
  }
 
  template <typename ListDistributionsByOriginRequestPolicyId2020_05_31RequestT =
                Model::ListDistributionsByOriginRequestPolicyId2020_05_31Request>
  void ListDistributionsByOriginRequestPolicyId2020_05_31Async(
      const ListDistributionsByOriginRequestPolicyId2020_05_31RequestT& request,
      const ListDistributionsByOriginRequestPolicyId2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::ListDistributionsByOriginRequestPolicyId2020_05_31, request, handler, context);
  }
 
  virtual Model::ListDistributionsByOwnedResource2020_05_31Outcome ListDistributionsByOwnedResource2020_05_31(
      const Model::ListDistributionsByOwnedResource2020_05_31Request& request) const;
 
  template <typename ListDistributionsByOwnedResource2020_05_31RequestT = Model::ListDistributionsByOwnedResource2020_05_31Request>
  Model::ListDistributionsByOwnedResource2020_05_31OutcomeCallable ListDistributionsByOwnedResource2020_05_31Callable(
      const ListDistributionsByOwnedResource2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::ListDistributionsByOwnedResource2020_05_31, request);
  }
 
  template <typename ListDistributionsByOwnedResource2020_05_31RequestT = Model::ListDistributionsByOwnedResource2020_05_31Request>
  void ListDistributionsByOwnedResource2020_05_31Async(
      const ListDistributionsByOwnedResource2020_05_31RequestT& request,
      const ListDistributionsByOwnedResource2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::ListDistributionsByOwnedResource2020_05_31, request, handler, context);
  }
 
  virtual Model::ListDistributionsByRealtimeLogConfig2020_05_31Outcome ListDistributionsByRealtimeLogConfig2020_05_31(
      const Model::ListDistributionsByRealtimeLogConfig2020_05_31Request& request = {}) const;
 
  template <typename ListDistributionsByRealtimeLogConfig2020_05_31RequestT = Model::ListDistributionsByRealtimeLogConfig2020_05_31Request>
  Model::ListDistributionsByRealtimeLogConfig2020_05_31OutcomeCallable ListDistributionsByRealtimeLogConfig2020_05_31Callable(
      const ListDistributionsByRealtimeLogConfig2020_05_31RequestT& request = {}) const {
    return SubmitCallable(&CloudFrontClient::ListDistributionsByRealtimeLogConfig2020_05_31, request);
  }
 
  template <typename ListDistributionsByRealtimeLogConfig2020_05_31RequestT = Model::ListDistributionsByRealtimeLogConfig2020_05_31Request>
  void ListDistributionsByRealtimeLogConfig2020_05_31Async(
      const ListDistributionsByRealtimeLogConfig2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
      const ListDistributionsByRealtimeLogConfig2020_05_31RequestT& request = {}) const {
    return SubmitAsync(&CloudFrontClient::ListDistributionsByRealtimeLogConfig2020_05_31, request, handler, context);
  }
 
  virtual Model::ListDistributionsByResponseHeadersPolicyId2020_05_31Outcome ListDistributionsByResponseHeadersPolicyId2020_05_31(
      const Model::ListDistributionsByResponseHeadersPolicyId2020_05_31Request& request) const;
 
  template <typename ListDistributionsByResponseHeadersPolicyId2020_05_31RequestT =
                Model::ListDistributionsByResponseHeadersPolicyId2020_05_31Request>
  Model::ListDistributionsByResponseHeadersPolicyId2020_05_31OutcomeCallable ListDistributionsByResponseHeadersPolicyId2020_05_31Callable(
      const ListDistributionsByResponseHeadersPolicyId2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::ListDistributionsByResponseHeadersPolicyId2020_05_31, request);
  }
 
  template <typename ListDistributionsByResponseHeadersPolicyId2020_05_31RequestT =
                Model::ListDistributionsByResponseHeadersPolicyId2020_05_31Request>
  void ListDistributionsByResponseHeadersPolicyId2020_05_31Async(
      const ListDistributionsByResponseHeadersPolicyId2020_05_31RequestT& request,
      const ListDistributionsByResponseHeadersPolicyId2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::ListDistributionsByResponseHeadersPolicyId2020_05_31, request, handler, context);
  }
 
  virtual Model::ListDistributionsByTrustStore2020_05_31Outcome ListDistributionsByTrustStore2020_05_31(
      const Model::ListDistributionsByTrustStore2020_05_31Request& request) const;
 
  template <typename ListDistributionsByTrustStore2020_05_31RequestT = Model::ListDistributionsByTrustStore2020_05_31Request>
  Model::ListDistributionsByTrustStore2020_05_31OutcomeCallable ListDistributionsByTrustStore2020_05_31Callable(
      const ListDistributionsByTrustStore2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::ListDistributionsByTrustStore2020_05_31, request);
  }
 
  template <typename ListDistributionsByTrustStore2020_05_31RequestT = Model::ListDistributionsByTrustStore2020_05_31Request>
  void ListDistributionsByTrustStore2020_05_31Async(const ListDistributionsByTrustStore2020_05_31RequestT& request,
                                                    const ListDistributionsByTrustStore2020_05_31ResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::ListDistributionsByTrustStore2020_05_31, request, handler, context);
  }
 
  virtual Model::ListDistributionsByVpcOriginId2020_05_31Outcome ListDistributionsByVpcOriginId2020_05_31(
      const Model::ListDistributionsByVpcOriginId2020_05_31Request& request) const;
 
  template <typename ListDistributionsByVpcOriginId2020_05_31RequestT = Model::ListDistributionsByVpcOriginId2020_05_31Request>
  Model::ListDistributionsByVpcOriginId2020_05_31OutcomeCallable ListDistributionsByVpcOriginId2020_05_31Callable(
      const ListDistributionsByVpcOriginId2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::ListDistributionsByVpcOriginId2020_05_31, request);
  }
 
  template <typename ListDistributionsByVpcOriginId2020_05_31RequestT = Model::ListDistributionsByVpcOriginId2020_05_31Request>
  void ListDistributionsByVpcOriginId2020_05_31Async(
      const ListDistributionsByVpcOriginId2020_05_31RequestT& request,
      const ListDistributionsByVpcOriginId2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::ListDistributionsByVpcOriginId2020_05_31, request, handler, context);
  }
 
  virtual Model::ListDistributionsByWebACLId2020_05_31Outcome ListDistributionsByWebACLId2020_05_31(
      const Model::ListDistributionsByWebACLId2020_05_31Request& request) const;
 
  template <typename ListDistributionsByWebACLId2020_05_31RequestT = Model::ListDistributionsByWebACLId2020_05_31Request>
  Model::ListDistributionsByWebACLId2020_05_31OutcomeCallable ListDistributionsByWebACLId2020_05_31Callable(
      const ListDistributionsByWebACLId2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::ListDistributionsByWebACLId2020_05_31, request);
  }
 
  template <typename ListDistributionsByWebACLId2020_05_31RequestT = Model::ListDistributionsByWebACLId2020_05_31Request>
  void ListDistributionsByWebACLId2020_05_31Async(const ListDistributionsByWebACLId2020_05_31RequestT& request,
                                                  const ListDistributionsByWebACLId2020_05_31ResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::ListDistributionsByWebACLId2020_05_31, request, handler, context);
  }
 
  virtual Model::ListDomainConflicts2020_05_31Outcome ListDomainConflicts2020_05_31(
      const Model::ListDomainConflicts2020_05_31Request& request) const;
 
  template <typename ListDomainConflicts2020_05_31RequestT = Model::ListDomainConflicts2020_05_31Request>
  Model::ListDomainConflicts2020_05_31OutcomeCallable ListDomainConflicts2020_05_31Callable(
      const ListDomainConflicts2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::ListDomainConflicts2020_05_31, request);
  }
 
  template <typename ListDomainConflicts2020_05_31RequestT = Model::ListDomainConflicts2020_05_31Request>
  void ListDomainConflicts2020_05_31Async(const ListDomainConflicts2020_05_31RequestT& request,
                                          const ListDomainConflicts2020_05_31ResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::ListDomainConflicts2020_05_31, request, handler, context);
  }
 
  virtual Model::ListFieldLevelEncryptionConfigs2020_05_31Outcome ListFieldLevelEncryptionConfigs2020_05_31(
      const Model::ListFieldLevelEncryptionConfigs2020_05_31Request& request = {}) const;
 
  template <typename ListFieldLevelEncryptionConfigs2020_05_31RequestT = Model::ListFieldLevelEncryptionConfigs2020_05_31Request>
  Model::ListFieldLevelEncryptionConfigs2020_05_31OutcomeCallable ListFieldLevelEncryptionConfigs2020_05_31Callable(
      const ListFieldLevelEncryptionConfigs2020_05_31RequestT& request = {}) const {
    return SubmitCallable(&CloudFrontClient::ListFieldLevelEncryptionConfigs2020_05_31, request);
  }
 
  template <typename ListFieldLevelEncryptionConfigs2020_05_31RequestT = Model::ListFieldLevelEncryptionConfigs2020_05_31Request>
  void ListFieldLevelEncryptionConfigs2020_05_31Async(const ListFieldLevelEncryptionConfigs2020_05_31ResponseReceivedHandler& handler,
                                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                      const ListFieldLevelEncryptionConfigs2020_05_31RequestT& request = {}) const {
    return SubmitAsync(&CloudFrontClient::ListFieldLevelEncryptionConfigs2020_05_31, request, handler, context);
  }
 
  virtual Model::ListFieldLevelEncryptionProfiles2020_05_31Outcome ListFieldLevelEncryptionProfiles2020_05_31(
      const Model::ListFieldLevelEncryptionProfiles2020_05_31Request& request = {}) const;
 
  template <typename ListFieldLevelEncryptionProfiles2020_05_31RequestT = Model::ListFieldLevelEncryptionProfiles2020_05_31Request>
  Model::ListFieldLevelEncryptionProfiles2020_05_31OutcomeCallable ListFieldLevelEncryptionProfiles2020_05_31Callable(
      const ListFieldLevelEncryptionProfiles2020_05_31RequestT& request = {}) const {
    return SubmitCallable(&CloudFrontClient::ListFieldLevelEncryptionProfiles2020_05_31, request);
  }
 
  template <typename ListFieldLevelEncryptionProfiles2020_05_31RequestT = Model::ListFieldLevelEncryptionProfiles2020_05_31Request>
  void ListFieldLevelEncryptionProfiles2020_05_31Async(const ListFieldLevelEncryptionProfiles2020_05_31ResponseReceivedHandler& handler,
                                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                       const ListFieldLevelEncryptionProfiles2020_05_31RequestT& request = {}) const {
    return SubmitAsync(&CloudFrontClient::ListFieldLevelEncryptionProfiles2020_05_31, request, handler, context);
  }
 
  virtual Model::ListFunctions2020_05_31Outcome ListFunctions2020_05_31(const Model::ListFunctions2020_05_31Request& request = {}) const;
 
  template <typename ListFunctions2020_05_31RequestT = Model::ListFunctions2020_05_31Request>
  Model::ListFunctions2020_05_31OutcomeCallable ListFunctions2020_05_31Callable(const ListFunctions2020_05_31RequestT& request = {}) const {
    return SubmitCallable(&CloudFrontClient::ListFunctions2020_05_31, request);
  }
 
  template <typename ListFunctions2020_05_31RequestT = Model::ListFunctions2020_05_31Request>
  void ListFunctions2020_05_31Async(const ListFunctions2020_05_31ResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListFunctions2020_05_31RequestT& request = {}) const {
    return SubmitAsync(&CloudFrontClient::ListFunctions2020_05_31, request, handler, context);
  }
 
  virtual Model::ListInvalidations2020_05_31Outcome ListInvalidations2020_05_31(
      const Model::ListInvalidations2020_05_31Request& request) const;
 
  template <typename ListInvalidations2020_05_31RequestT = Model::ListInvalidations2020_05_31Request>
  Model::ListInvalidations2020_05_31OutcomeCallable ListInvalidations2020_05_31Callable(
      const ListInvalidations2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::ListInvalidations2020_05_31, request);
  }
 
  template <typename ListInvalidations2020_05_31RequestT = Model::ListInvalidations2020_05_31Request>
  void ListInvalidations2020_05_31Async(const ListInvalidations2020_05_31RequestT& request,
                                        const ListInvalidations2020_05_31ResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::ListInvalidations2020_05_31, request, handler, context);
  }
 
  virtual Model::ListInvalidationsForDistributionTenant2020_05_31Outcome ListInvalidationsForDistributionTenant2020_05_31(
      const Model::ListInvalidationsForDistributionTenant2020_05_31Request& request) const;
 
  template <
      typename ListInvalidationsForDistributionTenant2020_05_31RequestT = Model::ListInvalidationsForDistributionTenant2020_05_31Request>
  Model::ListInvalidationsForDistributionTenant2020_05_31OutcomeCallable ListInvalidationsForDistributionTenant2020_05_31Callable(
      const ListInvalidationsForDistributionTenant2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::ListInvalidationsForDistributionTenant2020_05_31, request);
  }
 
  template <
      typename ListInvalidationsForDistributionTenant2020_05_31RequestT = Model::ListInvalidationsForDistributionTenant2020_05_31Request>
  void ListInvalidationsForDistributionTenant2020_05_31Async(
      const ListInvalidationsForDistributionTenant2020_05_31RequestT& request,
      const ListInvalidationsForDistributionTenant2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::ListInvalidationsForDistributionTenant2020_05_31, request, handler, context);
  }
 
  virtual Model::ListKeyGroups2020_05_31Outcome ListKeyGroups2020_05_31(const Model::ListKeyGroups2020_05_31Request& request = {}) const;
 
  template <typename ListKeyGroups2020_05_31RequestT = Model::ListKeyGroups2020_05_31Request>
  Model::ListKeyGroups2020_05_31OutcomeCallable ListKeyGroups2020_05_31Callable(const ListKeyGroups2020_05_31RequestT& request = {}) const {
    return SubmitCallable(&CloudFrontClient::ListKeyGroups2020_05_31, request);
  }
 
  template <typename ListKeyGroups2020_05_31RequestT = Model::ListKeyGroups2020_05_31Request>
  void ListKeyGroups2020_05_31Async(const ListKeyGroups2020_05_31ResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListKeyGroups2020_05_31RequestT& request = {}) const {
    return SubmitAsync(&CloudFrontClient::ListKeyGroups2020_05_31, request, handler, context);
  }
 
  virtual Model::ListKeyValueStores2020_05_31Outcome ListKeyValueStores2020_05_31(
      const Model::ListKeyValueStores2020_05_31Request& request = {}) const;
 
  template <typename ListKeyValueStores2020_05_31RequestT = Model::ListKeyValueStores2020_05_31Request>
  Model::ListKeyValueStores2020_05_31OutcomeCallable ListKeyValueStores2020_05_31Callable(
      const ListKeyValueStores2020_05_31RequestT& request = {}) const {
    return SubmitCallable(&CloudFrontClient::ListKeyValueStores2020_05_31, request);
  }
 
  template <typename ListKeyValueStores2020_05_31RequestT = Model::ListKeyValueStores2020_05_31Request>
  void ListKeyValueStores2020_05_31Async(const ListKeyValueStores2020_05_31ResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const ListKeyValueStores2020_05_31RequestT& request = {}) const {
    return SubmitAsync(&CloudFrontClient::ListKeyValueStores2020_05_31, request, handler, context);
  }
 
  virtual Model::ListOriginAccessControls2020_05_31Outcome ListOriginAccessControls2020_05_31(
      const Model::ListOriginAccessControls2020_05_31Request& request = {}) const;
 
  template <typename ListOriginAccessControls2020_05_31RequestT = Model::ListOriginAccessControls2020_05_31Request>
  Model::ListOriginAccessControls2020_05_31OutcomeCallable ListOriginAccessControls2020_05_31Callable(
      const ListOriginAccessControls2020_05_31RequestT& request = {}) const {
    return SubmitCallable(&CloudFrontClient::ListOriginAccessControls2020_05_31, request);
  }
 
  template <typename ListOriginAccessControls2020_05_31RequestT = Model::ListOriginAccessControls2020_05_31Request>
  void ListOriginAccessControls2020_05_31Async(const ListOriginAccessControls2020_05_31ResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                               const ListOriginAccessControls2020_05_31RequestT& request = {}) const {
    return SubmitAsync(&CloudFrontClient::ListOriginAccessControls2020_05_31, request, handler, context);
  }
 
  virtual Model::ListOriginRequestPolicies2020_05_31Outcome ListOriginRequestPolicies2020_05_31(
      const Model::ListOriginRequestPolicies2020_05_31Request& request = {}) const;
 
  template <typename ListOriginRequestPolicies2020_05_31RequestT = Model::ListOriginRequestPolicies2020_05_31Request>
  Model::ListOriginRequestPolicies2020_05_31OutcomeCallable ListOriginRequestPolicies2020_05_31Callable(
      const ListOriginRequestPolicies2020_05_31RequestT& request = {}) const {
    return SubmitCallable(&CloudFrontClient::ListOriginRequestPolicies2020_05_31, request);
  }
 
  template <typename ListOriginRequestPolicies2020_05_31RequestT = Model::ListOriginRequestPolicies2020_05_31Request>
  void ListOriginRequestPolicies2020_05_31Async(const ListOriginRequestPolicies2020_05_31ResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                const ListOriginRequestPolicies2020_05_31RequestT& request = {}) const {
    return SubmitAsync(&CloudFrontClient::ListOriginRequestPolicies2020_05_31, request, handler, context);
  }
 
  virtual Model::ListPublicKeys2020_05_31Outcome ListPublicKeys2020_05_31(const Model::ListPublicKeys2020_05_31Request& request = {}) const;
 
  template <typename ListPublicKeys2020_05_31RequestT = Model::ListPublicKeys2020_05_31Request>
  Model::ListPublicKeys2020_05_31OutcomeCallable ListPublicKeys2020_05_31Callable(
      const ListPublicKeys2020_05_31RequestT& request = {}) const {
    return SubmitCallable(&CloudFrontClient::ListPublicKeys2020_05_31, request);
  }
 
  template <typename ListPublicKeys2020_05_31RequestT = Model::ListPublicKeys2020_05_31Request>
  void ListPublicKeys2020_05_31Async(const ListPublicKeys2020_05_31ResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListPublicKeys2020_05_31RequestT& request = {}) const {
    return SubmitAsync(&CloudFrontClient::ListPublicKeys2020_05_31, request, handler, context);
  }
 
  virtual Model::ListRealtimeLogConfigs2020_05_31Outcome ListRealtimeLogConfigs2020_05_31(
      const Model::ListRealtimeLogConfigs2020_05_31Request& request = {}) const;
 
  template <typename ListRealtimeLogConfigs2020_05_31RequestT = Model::ListRealtimeLogConfigs2020_05_31Request>
  Model::ListRealtimeLogConfigs2020_05_31OutcomeCallable ListRealtimeLogConfigs2020_05_31Callable(
      const ListRealtimeLogConfigs2020_05_31RequestT& request = {}) const {
    return SubmitCallable(&CloudFrontClient::ListRealtimeLogConfigs2020_05_31, request);
  }
 
  template <typename ListRealtimeLogConfigs2020_05_31RequestT = Model::ListRealtimeLogConfigs2020_05_31Request>
  void ListRealtimeLogConfigs2020_05_31Async(const ListRealtimeLogConfigs2020_05_31ResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                             const ListRealtimeLogConfigs2020_05_31RequestT& request = {}) const {
    return SubmitAsync(&CloudFrontClient::ListRealtimeLogConfigs2020_05_31, request, handler, context);
  }
 
  virtual Model::ListResponseHeadersPolicies2020_05_31Outcome ListResponseHeadersPolicies2020_05_31(
      const Model::ListResponseHeadersPolicies2020_05_31Request& request = {}) const;
 
  template <typename ListResponseHeadersPolicies2020_05_31RequestT = Model::ListResponseHeadersPolicies2020_05_31Request>
  Model::ListResponseHeadersPolicies2020_05_31OutcomeCallable ListResponseHeadersPolicies2020_05_31Callable(
      const ListResponseHeadersPolicies2020_05_31RequestT& request = {}) const {
    return SubmitCallable(&CloudFrontClient::ListResponseHeadersPolicies2020_05_31, request);
  }
 
  template <typename ListResponseHeadersPolicies2020_05_31RequestT = Model::ListResponseHeadersPolicies2020_05_31Request>
  void ListResponseHeadersPolicies2020_05_31Async(const ListResponseHeadersPolicies2020_05_31ResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                  const ListResponseHeadersPolicies2020_05_31RequestT& request = {}) const {
    return SubmitAsync(&CloudFrontClient::ListResponseHeadersPolicies2020_05_31, request, handler, context);
  }
 
  virtual Model::ListStreamingDistributions2020_05_31Outcome ListStreamingDistributions2020_05_31(
      const Model::ListStreamingDistributions2020_05_31Request& request = {}) const;
 
  template <typename ListStreamingDistributions2020_05_31RequestT = Model::ListStreamingDistributions2020_05_31Request>
  Model::ListStreamingDistributions2020_05_31OutcomeCallable ListStreamingDistributions2020_05_31Callable(
      const ListStreamingDistributions2020_05_31RequestT& request = {}) const {
    return SubmitCallable(&CloudFrontClient::ListStreamingDistributions2020_05_31, request);
  }
 
  template <typename ListStreamingDistributions2020_05_31RequestT = Model::ListStreamingDistributions2020_05_31Request>
  void ListStreamingDistributions2020_05_31Async(const ListStreamingDistributions2020_05_31ResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                 const ListStreamingDistributions2020_05_31RequestT& request = {}) const {
    return SubmitAsync(&CloudFrontClient::ListStreamingDistributions2020_05_31, request, handler, context);
  }
 
  virtual Model::ListTagsForResource2020_05_31Outcome ListTagsForResource2020_05_31(
      const Model::ListTagsForResource2020_05_31Request& request) const;
 
  template <typename ListTagsForResource2020_05_31RequestT = Model::ListTagsForResource2020_05_31Request>
  Model::ListTagsForResource2020_05_31OutcomeCallable ListTagsForResource2020_05_31Callable(
      const ListTagsForResource2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::ListTagsForResource2020_05_31, request);
  }
 
  template <typename ListTagsForResource2020_05_31RequestT = Model::ListTagsForResource2020_05_31Request>
  void ListTagsForResource2020_05_31Async(const ListTagsForResource2020_05_31RequestT& request,
                                          const ListTagsForResource2020_05_31ResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::ListTagsForResource2020_05_31, request, handler, context);
  }
 
  virtual Model::ListTrustStores2020_05_31Outcome ListTrustStores2020_05_31(
      const Model::ListTrustStores2020_05_31Request& request = {}) const;
 
  template <typename ListTrustStores2020_05_31RequestT = Model::ListTrustStores2020_05_31Request>
  Model::ListTrustStores2020_05_31OutcomeCallable ListTrustStores2020_05_31Callable(
      const ListTrustStores2020_05_31RequestT& request = {}) const {
    return SubmitCallable(&CloudFrontClient::ListTrustStores2020_05_31, request);
  }
 
  template <typename ListTrustStores2020_05_31RequestT = Model::ListTrustStores2020_05_31Request>
  void ListTrustStores2020_05_31Async(const ListTrustStores2020_05_31ResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListTrustStores2020_05_31RequestT& request = {}) const {
    return SubmitAsync(&CloudFrontClient::ListTrustStores2020_05_31, request, handler, context);
  }
 
  virtual Model::ListVpcOrigins2020_05_31Outcome ListVpcOrigins2020_05_31(const Model::ListVpcOrigins2020_05_31Request& request = {}) const;
 
  template <typename ListVpcOrigins2020_05_31RequestT = Model::ListVpcOrigins2020_05_31Request>
  Model::ListVpcOrigins2020_05_31OutcomeCallable ListVpcOrigins2020_05_31Callable(
      const ListVpcOrigins2020_05_31RequestT& request = {}) const {
    return SubmitCallable(&CloudFrontClient::ListVpcOrigins2020_05_31, request);
  }
 
  template <typename ListVpcOrigins2020_05_31RequestT = Model::ListVpcOrigins2020_05_31Request>
  void ListVpcOrigins2020_05_31Async(const ListVpcOrigins2020_05_31ResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListVpcOrigins2020_05_31RequestT& request = {}) const {
    return SubmitAsync(&CloudFrontClient::ListVpcOrigins2020_05_31, request, handler, context);
  }
 
  virtual Model::PublishConnectionFunction2020_05_31Outcome PublishConnectionFunction2020_05_31(
      const Model::PublishConnectionFunction2020_05_31Request& request) const;
 
  template <typename PublishConnectionFunction2020_05_31RequestT = Model::PublishConnectionFunction2020_05_31Request>
  Model::PublishConnectionFunction2020_05_31OutcomeCallable PublishConnectionFunction2020_05_31Callable(
      const PublishConnectionFunction2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::PublishConnectionFunction2020_05_31, request);
  }
 
  template <typename PublishConnectionFunction2020_05_31RequestT = Model::PublishConnectionFunction2020_05_31Request>
  void PublishConnectionFunction2020_05_31Async(const PublishConnectionFunction2020_05_31RequestT& request,
                                                const PublishConnectionFunction2020_05_31ResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::PublishConnectionFunction2020_05_31, request, handler, context);
  }
 
  virtual Model::PublishFunction2020_05_31Outcome PublishFunction2020_05_31(const Model::PublishFunction2020_05_31Request& request) const;
 
  template <typename PublishFunction2020_05_31RequestT = Model::PublishFunction2020_05_31Request>
  Model::PublishFunction2020_05_31OutcomeCallable PublishFunction2020_05_31Callable(
      const PublishFunction2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::PublishFunction2020_05_31, request);
  }
 
  template <typename PublishFunction2020_05_31RequestT = Model::PublishFunction2020_05_31Request>
  void PublishFunction2020_05_31Async(const PublishFunction2020_05_31RequestT& request,
                                      const PublishFunction2020_05_31ResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::PublishFunction2020_05_31, request, handler, context);
  }
 
  virtual Model::PutResourcePolicy2020_05_31Outcome PutResourcePolicy2020_05_31(
      const Model::PutResourcePolicy2020_05_31Request& request) const;
 
  template <typename PutResourcePolicy2020_05_31RequestT = Model::PutResourcePolicy2020_05_31Request>
  Model::PutResourcePolicy2020_05_31OutcomeCallable PutResourcePolicy2020_05_31Callable(
      const PutResourcePolicy2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::PutResourcePolicy2020_05_31, request);
  }
 
  template <typename PutResourcePolicy2020_05_31RequestT = Model::PutResourcePolicy2020_05_31Request>
  void PutResourcePolicy2020_05_31Async(const PutResourcePolicy2020_05_31RequestT& request,
                                        const PutResourcePolicy2020_05_31ResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::PutResourcePolicy2020_05_31, request, handler, context);
  }
 
  virtual Model::TagResource2020_05_31Outcome TagResource2020_05_31(const Model::TagResource2020_05_31Request& request) const;
 
  template <typename TagResource2020_05_31RequestT = Model::TagResource2020_05_31Request>
  Model::TagResource2020_05_31OutcomeCallable TagResource2020_05_31Callable(const TagResource2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::TagResource2020_05_31, request);
  }
 
  template <typename TagResource2020_05_31RequestT = Model::TagResource2020_05_31Request>
  void TagResource2020_05_31Async(const TagResource2020_05_31RequestT& request, const TagResource2020_05_31ResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::TagResource2020_05_31, request, handler, context);
  }
 
  virtual Model::TestConnectionFunction2020_05_31Outcome TestConnectionFunction2020_05_31(
      const Model::TestConnectionFunction2020_05_31Request& request) const;
 
  template <typename TestConnectionFunction2020_05_31RequestT = Model::TestConnectionFunction2020_05_31Request>
  Model::TestConnectionFunction2020_05_31OutcomeCallable TestConnectionFunction2020_05_31Callable(
      const TestConnectionFunction2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::TestConnectionFunction2020_05_31, request);
  }
 
  template <typename TestConnectionFunction2020_05_31RequestT = Model::TestConnectionFunction2020_05_31Request>
  void TestConnectionFunction2020_05_31Async(const TestConnectionFunction2020_05_31RequestT& request,
                                             const TestConnectionFunction2020_05_31ResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::TestConnectionFunction2020_05_31, request, handler, context);
  }
 
  virtual Model::TestFunction2020_05_31Outcome TestFunction2020_05_31(const Model::TestFunction2020_05_31Request& request) const;
 
  template <typename TestFunction2020_05_31RequestT = Model::TestFunction2020_05_31Request>
  Model::TestFunction2020_05_31OutcomeCallable TestFunction2020_05_31Callable(const TestFunction2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::TestFunction2020_05_31, request);
  }
 
  template <typename TestFunction2020_05_31RequestT = Model::TestFunction2020_05_31Request>
  void TestFunction2020_05_31Async(const TestFunction2020_05_31RequestT& request,
                                   const TestFunction2020_05_31ResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::TestFunction2020_05_31, request, handler, context);
  }
 
  virtual Model::UntagResource2020_05_31Outcome UntagResource2020_05_31(const Model::UntagResource2020_05_31Request& request) const;
 
  template <typename UntagResource2020_05_31RequestT = Model::UntagResource2020_05_31Request>
  Model::UntagResource2020_05_31OutcomeCallable UntagResource2020_05_31Callable(const UntagResource2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::UntagResource2020_05_31, request);
  }
 
  template <typename UntagResource2020_05_31RequestT = Model::UntagResource2020_05_31Request>
  void UntagResource2020_05_31Async(const UntagResource2020_05_31RequestT& request,
                                    const UntagResource2020_05_31ResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::UntagResource2020_05_31, request, handler, context);
  }
 
  virtual Model::UpdateAnycastIpList2020_05_31Outcome UpdateAnycastIpList2020_05_31(
      const Model::UpdateAnycastIpList2020_05_31Request& request) const;
 
  template <typename UpdateAnycastIpList2020_05_31RequestT = Model::UpdateAnycastIpList2020_05_31Request>
  Model::UpdateAnycastIpList2020_05_31OutcomeCallable UpdateAnycastIpList2020_05_31Callable(
      const UpdateAnycastIpList2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::UpdateAnycastIpList2020_05_31, request);
  }
 
  template <typename UpdateAnycastIpList2020_05_31RequestT = Model::UpdateAnycastIpList2020_05_31Request>
  void UpdateAnycastIpList2020_05_31Async(const UpdateAnycastIpList2020_05_31RequestT& request,
                                          const UpdateAnycastIpList2020_05_31ResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::UpdateAnycastIpList2020_05_31, request, handler, context);
  }
 
  virtual Model::UpdateCachePolicy2020_05_31Outcome UpdateCachePolicy2020_05_31(
      const Model::UpdateCachePolicy2020_05_31Request& request) const;
 
  template <typename UpdateCachePolicy2020_05_31RequestT = Model::UpdateCachePolicy2020_05_31Request>
  Model::UpdateCachePolicy2020_05_31OutcomeCallable UpdateCachePolicy2020_05_31Callable(
      const UpdateCachePolicy2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::UpdateCachePolicy2020_05_31, request);
  }
 
  template <typename UpdateCachePolicy2020_05_31RequestT = Model::UpdateCachePolicy2020_05_31Request>
  void UpdateCachePolicy2020_05_31Async(const UpdateCachePolicy2020_05_31RequestT& request,
                                        const UpdateCachePolicy2020_05_31ResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::UpdateCachePolicy2020_05_31, request, handler, context);
  }
 
  virtual Model::UpdateCloudFrontOriginAccessIdentity2020_05_31Outcome UpdateCloudFrontOriginAccessIdentity2020_05_31(
      const Model::UpdateCloudFrontOriginAccessIdentity2020_05_31Request& request) const;
 
  template <typename UpdateCloudFrontOriginAccessIdentity2020_05_31RequestT = Model::UpdateCloudFrontOriginAccessIdentity2020_05_31Request>
  Model::UpdateCloudFrontOriginAccessIdentity2020_05_31OutcomeCallable UpdateCloudFrontOriginAccessIdentity2020_05_31Callable(
      const UpdateCloudFrontOriginAccessIdentity2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::UpdateCloudFrontOriginAccessIdentity2020_05_31, request);
  }
 
  template <typename UpdateCloudFrontOriginAccessIdentity2020_05_31RequestT = Model::UpdateCloudFrontOriginAccessIdentity2020_05_31Request>
  void UpdateCloudFrontOriginAccessIdentity2020_05_31Async(
      const UpdateCloudFrontOriginAccessIdentity2020_05_31RequestT& request,
      const UpdateCloudFrontOriginAccessIdentity2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::UpdateCloudFrontOriginAccessIdentity2020_05_31, request, handler, context);
  }
 
  virtual Model::UpdateConnectionFunction2020_05_31Outcome UpdateConnectionFunction2020_05_31(
      const Model::UpdateConnectionFunction2020_05_31Request& request) const;
 
  template <typename UpdateConnectionFunction2020_05_31RequestT = Model::UpdateConnectionFunction2020_05_31Request>
  Model::UpdateConnectionFunction2020_05_31OutcomeCallable UpdateConnectionFunction2020_05_31Callable(
      const UpdateConnectionFunction2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::UpdateConnectionFunction2020_05_31, request);
  }
 
  template <typename UpdateConnectionFunction2020_05_31RequestT = Model::UpdateConnectionFunction2020_05_31Request>
  void UpdateConnectionFunction2020_05_31Async(const UpdateConnectionFunction2020_05_31RequestT& request,
                                               const UpdateConnectionFunction2020_05_31ResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::UpdateConnectionFunction2020_05_31, request, handler, context);
  }
 
  virtual Model::UpdateConnectionGroup2020_05_31Outcome UpdateConnectionGroup2020_05_31(
      const Model::UpdateConnectionGroup2020_05_31Request& request) const;
 
  template <typename UpdateConnectionGroup2020_05_31RequestT = Model::UpdateConnectionGroup2020_05_31Request>
  Model::UpdateConnectionGroup2020_05_31OutcomeCallable UpdateConnectionGroup2020_05_31Callable(
      const UpdateConnectionGroup2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::UpdateConnectionGroup2020_05_31, request);
  }
 
  template <typename UpdateConnectionGroup2020_05_31RequestT = Model::UpdateConnectionGroup2020_05_31Request>
  void UpdateConnectionGroup2020_05_31Async(const UpdateConnectionGroup2020_05_31RequestT& request,
                                            const UpdateConnectionGroup2020_05_31ResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::UpdateConnectionGroup2020_05_31, request, handler, context);
  }
 
  virtual Model::UpdateContinuousDeploymentPolicy2020_05_31Outcome UpdateContinuousDeploymentPolicy2020_05_31(
      const Model::UpdateContinuousDeploymentPolicy2020_05_31Request& request) const;
 
  template <typename UpdateContinuousDeploymentPolicy2020_05_31RequestT = Model::UpdateContinuousDeploymentPolicy2020_05_31Request>
  Model::UpdateContinuousDeploymentPolicy2020_05_31OutcomeCallable UpdateContinuousDeploymentPolicy2020_05_31Callable(
      const UpdateContinuousDeploymentPolicy2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::UpdateContinuousDeploymentPolicy2020_05_31, request);
  }
 
  template <typename UpdateContinuousDeploymentPolicy2020_05_31RequestT = Model::UpdateContinuousDeploymentPolicy2020_05_31Request>
  void UpdateContinuousDeploymentPolicy2020_05_31Async(
      const UpdateContinuousDeploymentPolicy2020_05_31RequestT& request,
      const UpdateContinuousDeploymentPolicy2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::UpdateContinuousDeploymentPolicy2020_05_31, request, handler, context);
  }
 
  virtual Model::UpdateDistribution2020_05_31Outcome UpdateDistribution2020_05_31(
      const Model::UpdateDistribution2020_05_31Request& request) const;
 
  template <typename UpdateDistribution2020_05_31RequestT = Model::UpdateDistribution2020_05_31Request>
  Model::UpdateDistribution2020_05_31OutcomeCallable UpdateDistribution2020_05_31Callable(
      const UpdateDistribution2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::UpdateDistribution2020_05_31, request);
  }
 
  template <typename UpdateDistribution2020_05_31RequestT = Model::UpdateDistribution2020_05_31Request>
  void UpdateDistribution2020_05_31Async(const UpdateDistribution2020_05_31RequestT& request,
                                         const UpdateDistribution2020_05_31ResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::UpdateDistribution2020_05_31, request, handler, context);
  }
 
  virtual Model::UpdateDistributionTenant2020_05_31Outcome UpdateDistributionTenant2020_05_31(
      const Model::UpdateDistributionTenant2020_05_31Request& request) const;
 
  template <typename UpdateDistributionTenant2020_05_31RequestT = Model::UpdateDistributionTenant2020_05_31Request>
  Model::UpdateDistributionTenant2020_05_31OutcomeCallable UpdateDistributionTenant2020_05_31Callable(
      const UpdateDistributionTenant2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::UpdateDistributionTenant2020_05_31, request);
  }
 
  template <typename UpdateDistributionTenant2020_05_31RequestT = Model::UpdateDistributionTenant2020_05_31Request>
  void UpdateDistributionTenant2020_05_31Async(const UpdateDistributionTenant2020_05_31RequestT& request,
                                               const UpdateDistributionTenant2020_05_31ResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::UpdateDistributionTenant2020_05_31, request, handler, context);
  }
 
  virtual Model::UpdateDistributionWithStagingConfig2020_05_31Outcome UpdateDistributionWithStagingConfig2020_05_31(
      const Model::UpdateDistributionWithStagingConfig2020_05_31Request& request) const;
 
  template <typename UpdateDistributionWithStagingConfig2020_05_31RequestT = Model::UpdateDistributionWithStagingConfig2020_05_31Request>
  Model::UpdateDistributionWithStagingConfig2020_05_31OutcomeCallable UpdateDistributionWithStagingConfig2020_05_31Callable(
      const UpdateDistributionWithStagingConfig2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::UpdateDistributionWithStagingConfig2020_05_31, request);
  }
 
  template <typename UpdateDistributionWithStagingConfig2020_05_31RequestT = Model::UpdateDistributionWithStagingConfig2020_05_31Request>
  void UpdateDistributionWithStagingConfig2020_05_31Async(
      const UpdateDistributionWithStagingConfig2020_05_31RequestT& request,
      const UpdateDistributionWithStagingConfig2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::UpdateDistributionWithStagingConfig2020_05_31, request, handler, context);
  }
 
  virtual Model::UpdateDomainAssociation2020_05_31Outcome UpdateDomainAssociation2020_05_31(
      const Model::UpdateDomainAssociation2020_05_31Request& request) const;
 
  template <typename UpdateDomainAssociation2020_05_31RequestT = Model::UpdateDomainAssociation2020_05_31Request>
  Model::UpdateDomainAssociation2020_05_31OutcomeCallable UpdateDomainAssociation2020_05_31Callable(
      const UpdateDomainAssociation2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::UpdateDomainAssociation2020_05_31, request);
  }
 
  template <typename UpdateDomainAssociation2020_05_31RequestT = Model::UpdateDomainAssociation2020_05_31Request>
  void UpdateDomainAssociation2020_05_31Async(const UpdateDomainAssociation2020_05_31RequestT& request,
                                              const UpdateDomainAssociation2020_05_31ResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::UpdateDomainAssociation2020_05_31, request, handler, context);
  }
 
  virtual Model::UpdateFieldLevelEncryptionConfig2020_05_31Outcome UpdateFieldLevelEncryptionConfig2020_05_31(
      const Model::UpdateFieldLevelEncryptionConfig2020_05_31Request& request) const;
 
  template <typename UpdateFieldLevelEncryptionConfig2020_05_31RequestT = Model::UpdateFieldLevelEncryptionConfig2020_05_31Request>
  Model::UpdateFieldLevelEncryptionConfig2020_05_31OutcomeCallable UpdateFieldLevelEncryptionConfig2020_05_31Callable(
      const UpdateFieldLevelEncryptionConfig2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::UpdateFieldLevelEncryptionConfig2020_05_31, request);
  }
 
  template <typename UpdateFieldLevelEncryptionConfig2020_05_31RequestT = Model::UpdateFieldLevelEncryptionConfig2020_05_31Request>
  void UpdateFieldLevelEncryptionConfig2020_05_31Async(
      const UpdateFieldLevelEncryptionConfig2020_05_31RequestT& request,
      const UpdateFieldLevelEncryptionConfig2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::UpdateFieldLevelEncryptionConfig2020_05_31, request, handler, context);
  }
 
  virtual Model::UpdateFieldLevelEncryptionProfile2020_05_31Outcome UpdateFieldLevelEncryptionProfile2020_05_31(
      const Model::UpdateFieldLevelEncryptionProfile2020_05_31Request& request) const;
 
  template <typename UpdateFieldLevelEncryptionProfile2020_05_31RequestT = Model::UpdateFieldLevelEncryptionProfile2020_05_31Request>
  Model::UpdateFieldLevelEncryptionProfile2020_05_31OutcomeCallable UpdateFieldLevelEncryptionProfile2020_05_31Callable(
      const UpdateFieldLevelEncryptionProfile2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::UpdateFieldLevelEncryptionProfile2020_05_31, request);
  }
 
  template <typename UpdateFieldLevelEncryptionProfile2020_05_31RequestT = Model::UpdateFieldLevelEncryptionProfile2020_05_31Request>
  void UpdateFieldLevelEncryptionProfile2020_05_31Async(
      const UpdateFieldLevelEncryptionProfile2020_05_31RequestT& request,
      const UpdateFieldLevelEncryptionProfile2020_05_31ResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::UpdateFieldLevelEncryptionProfile2020_05_31, request, handler, context);
  }
 
  virtual Model::UpdateFunction2020_05_31Outcome UpdateFunction2020_05_31(const Model::UpdateFunction2020_05_31Request& request) const;
 
  template <typename UpdateFunction2020_05_31RequestT = Model::UpdateFunction2020_05_31Request>
  Model::UpdateFunction2020_05_31OutcomeCallable UpdateFunction2020_05_31Callable(const UpdateFunction2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::UpdateFunction2020_05_31, request);
  }
 
  template <typename UpdateFunction2020_05_31RequestT = Model::UpdateFunction2020_05_31Request>
  void UpdateFunction2020_05_31Async(const UpdateFunction2020_05_31RequestT& request,
                                     const UpdateFunction2020_05_31ResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::UpdateFunction2020_05_31, request, handler, context);
  }
 
  virtual Model::UpdateKeyGroup2020_05_31Outcome UpdateKeyGroup2020_05_31(const Model::UpdateKeyGroup2020_05_31Request& request) const;
 
  template <typename UpdateKeyGroup2020_05_31RequestT = Model::UpdateKeyGroup2020_05_31Request>
  Model::UpdateKeyGroup2020_05_31OutcomeCallable UpdateKeyGroup2020_05_31Callable(const UpdateKeyGroup2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::UpdateKeyGroup2020_05_31, request);
  }
 
  template <typename UpdateKeyGroup2020_05_31RequestT = Model::UpdateKeyGroup2020_05_31Request>
  void UpdateKeyGroup2020_05_31Async(const UpdateKeyGroup2020_05_31RequestT& request,
                                     const UpdateKeyGroup2020_05_31ResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::UpdateKeyGroup2020_05_31, request, handler, context);
  }
 
  virtual Model::UpdateKeyValueStore2020_05_31Outcome UpdateKeyValueStore2020_05_31(
      const Model::UpdateKeyValueStore2020_05_31Request& request) const;
 
  template <typename UpdateKeyValueStore2020_05_31RequestT = Model::UpdateKeyValueStore2020_05_31Request>
  Model::UpdateKeyValueStore2020_05_31OutcomeCallable UpdateKeyValueStore2020_05_31Callable(
      const UpdateKeyValueStore2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::UpdateKeyValueStore2020_05_31, request);
  }
 
  template <typename UpdateKeyValueStore2020_05_31RequestT = Model::UpdateKeyValueStore2020_05_31Request>
  void UpdateKeyValueStore2020_05_31Async(const UpdateKeyValueStore2020_05_31RequestT& request,
                                          const UpdateKeyValueStore2020_05_31ResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::UpdateKeyValueStore2020_05_31, request, handler, context);
  }
 
  virtual Model::UpdateOriginAccessControl2020_05_31Outcome UpdateOriginAccessControl2020_05_31(
      const Model::UpdateOriginAccessControl2020_05_31Request& request) const;
 
  template <typename UpdateOriginAccessControl2020_05_31RequestT = Model::UpdateOriginAccessControl2020_05_31Request>
  Model::UpdateOriginAccessControl2020_05_31OutcomeCallable UpdateOriginAccessControl2020_05_31Callable(
      const UpdateOriginAccessControl2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::UpdateOriginAccessControl2020_05_31, request);
  }
 
  template <typename UpdateOriginAccessControl2020_05_31RequestT = Model::UpdateOriginAccessControl2020_05_31Request>
  void UpdateOriginAccessControl2020_05_31Async(const UpdateOriginAccessControl2020_05_31RequestT& request,
                                                const UpdateOriginAccessControl2020_05_31ResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::UpdateOriginAccessControl2020_05_31, request, handler, context);
  }
 
  virtual Model::UpdateOriginRequestPolicy2020_05_31Outcome UpdateOriginRequestPolicy2020_05_31(
      const Model::UpdateOriginRequestPolicy2020_05_31Request& request) const;
 
  template <typename UpdateOriginRequestPolicy2020_05_31RequestT = Model::UpdateOriginRequestPolicy2020_05_31Request>
  Model::UpdateOriginRequestPolicy2020_05_31OutcomeCallable UpdateOriginRequestPolicy2020_05_31Callable(
      const UpdateOriginRequestPolicy2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::UpdateOriginRequestPolicy2020_05_31, request);
  }
 
  template <typename UpdateOriginRequestPolicy2020_05_31RequestT = Model::UpdateOriginRequestPolicy2020_05_31Request>
  void UpdateOriginRequestPolicy2020_05_31Async(const UpdateOriginRequestPolicy2020_05_31RequestT& request,
                                                const UpdateOriginRequestPolicy2020_05_31ResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::UpdateOriginRequestPolicy2020_05_31, request, handler, context);
  }
 
  virtual Model::UpdatePublicKey2020_05_31Outcome UpdatePublicKey2020_05_31(const Model::UpdatePublicKey2020_05_31Request& request) const;
 
  template <typename UpdatePublicKey2020_05_31RequestT = Model::UpdatePublicKey2020_05_31Request>
  Model::UpdatePublicKey2020_05_31OutcomeCallable UpdatePublicKey2020_05_31Callable(
      const UpdatePublicKey2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::UpdatePublicKey2020_05_31, request);
  }
 
  template <typename UpdatePublicKey2020_05_31RequestT = Model::UpdatePublicKey2020_05_31Request>
  void UpdatePublicKey2020_05_31Async(const UpdatePublicKey2020_05_31RequestT& request,
                                      const UpdatePublicKey2020_05_31ResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::UpdatePublicKey2020_05_31, request, handler, context);
  }
 
  virtual Model::UpdateRealtimeLogConfig2020_05_31Outcome UpdateRealtimeLogConfig2020_05_31(
      const Model::UpdateRealtimeLogConfig2020_05_31Request& request = {}) const;
 
  template <typename UpdateRealtimeLogConfig2020_05_31RequestT = Model::UpdateRealtimeLogConfig2020_05_31Request>
  Model::UpdateRealtimeLogConfig2020_05_31OutcomeCallable UpdateRealtimeLogConfig2020_05_31Callable(
      const UpdateRealtimeLogConfig2020_05_31RequestT& request = {}) const {
    return SubmitCallable(&CloudFrontClient::UpdateRealtimeLogConfig2020_05_31, request);
  }
 
  template <typename UpdateRealtimeLogConfig2020_05_31RequestT = Model::UpdateRealtimeLogConfig2020_05_31Request>
  void UpdateRealtimeLogConfig2020_05_31Async(const UpdateRealtimeLogConfig2020_05_31ResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const UpdateRealtimeLogConfig2020_05_31RequestT& request = {}) const {
    return SubmitAsync(&CloudFrontClient::UpdateRealtimeLogConfig2020_05_31, request, handler, context);
  }
 
  virtual Model::UpdateResponseHeadersPolicy2020_05_31Outcome UpdateResponseHeadersPolicy2020_05_31(
      const Model::UpdateResponseHeadersPolicy2020_05_31Request& request) const;
 
  template <typename UpdateResponseHeadersPolicy2020_05_31RequestT = Model::UpdateResponseHeadersPolicy2020_05_31Request>
  Model::UpdateResponseHeadersPolicy2020_05_31OutcomeCallable UpdateResponseHeadersPolicy2020_05_31Callable(
      const UpdateResponseHeadersPolicy2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::UpdateResponseHeadersPolicy2020_05_31, request);
  }
 
  template <typename UpdateResponseHeadersPolicy2020_05_31RequestT = Model::UpdateResponseHeadersPolicy2020_05_31Request>
  void UpdateResponseHeadersPolicy2020_05_31Async(const UpdateResponseHeadersPolicy2020_05_31RequestT& request,
                                                  const UpdateResponseHeadersPolicy2020_05_31ResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::UpdateResponseHeadersPolicy2020_05_31, request, handler, context);
  }
 
  virtual Model::UpdateStreamingDistribution2020_05_31Outcome UpdateStreamingDistribution2020_05_31(
      const Model::UpdateStreamingDistribution2020_05_31Request& request) const;
 
  template <typename UpdateStreamingDistribution2020_05_31RequestT = Model::UpdateStreamingDistribution2020_05_31Request>
  Model::UpdateStreamingDistribution2020_05_31OutcomeCallable UpdateStreamingDistribution2020_05_31Callable(
      const UpdateStreamingDistribution2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::UpdateStreamingDistribution2020_05_31, request);
  }
 
  template <typename UpdateStreamingDistribution2020_05_31RequestT = Model::UpdateStreamingDistribution2020_05_31Request>
  void UpdateStreamingDistribution2020_05_31Async(const UpdateStreamingDistribution2020_05_31RequestT& request,
                                                  const UpdateStreamingDistribution2020_05_31ResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::UpdateStreamingDistribution2020_05_31, request, handler, context);
  }
 
  virtual Model::UpdateTrustStore2020_05_31Outcome UpdateTrustStore2020_05_31(
      const Model::UpdateTrustStore2020_05_31Request& request) const;
 
  template <typename UpdateTrustStore2020_05_31RequestT = Model::UpdateTrustStore2020_05_31Request>
  Model::UpdateTrustStore2020_05_31OutcomeCallable UpdateTrustStore2020_05_31Callable(
      const UpdateTrustStore2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::UpdateTrustStore2020_05_31, request);
  }
 
  template <typename UpdateTrustStore2020_05_31RequestT = Model::UpdateTrustStore2020_05_31Request>
  void UpdateTrustStore2020_05_31Async(const UpdateTrustStore2020_05_31RequestT& request,
                                       const UpdateTrustStore2020_05_31ResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::UpdateTrustStore2020_05_31, request, handler, context);
  }
 
  virtual Model::UpdateVpcOrigin2020_05_31Outcome UpdateVpcOrigin2020_05_31(const Model::UpdateVpcOrigin2020_05_31Request& request) const;
 
  template <typename UpdateVpcOrigin2020_05_31RequestT = Model::UpdateVpcOrigin2020_05_31Request>
  Model::UpdateVpcOrigin2020_05_31OutcomeCallable UpdateVpcOrigin2020_05_31Callable(
      const UpdateVpcOrigin2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::UpdateVpcOrigin2020_05_31, request);
  }
 
  template <typename UpdateVpcOrigin2020_05_31RequestT = Model::UpdateVpcOrigin2020_05_31Request>
  void UpdateVpcOrigin2020_05_31Async(const UpdateVpcOrigin2020_05_31RequestT& request,
                                      const UpdateVpcOrigin2020_05_31ResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::UpdateVpcOrigin2020_05_31, request, handler, context);
  }
 
  virtual Model::VerifyDnsConfiguration2020_05_31Outcome VerifyDnsConfiguration2020_05_31(
      const Model::VerifyDnsConfiguration2020_05_31Request& request) const;
 
  template <typename VerifyDnsConfiguration2020_05_31RequestT = Model::VerifyDnsConfiguration2020_05_31Request>
  Model::VerifyDnsConfiguration2020_05_31OutcomeCallable VerifyDnsConfiguration2020_05_31Callable(
      const VerifyDnsConfiguration2020_05_31RequestT& request) const {
    return SubmitCallable(&CloudFrontClient::VerifyDnsConfiguration2020_05_31, request);
  }
 
  template <typename VerifyDnsConfiguration2020_05_31RequestT = Model::VerifyDnsConfiguration2020_05_31Request>
  void VerifyDnsConfiguration2020_05_31Async(const VerifyDnsConfiguration2020_05_31RequestT& request,
                                             const VerifyDnsConfiguration2020_05_31ResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudFrontClient::VerifyDnsConfiguration2020_05_31, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<CloudFrontEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<CloudFrontClient>;
  void init(const CloudFrontClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, CloudFrontError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  CloudFrontClientConfiguration m_clientConfiguration;
  std::shared_ptr<CloudFrontEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace CloudFront
}  // namespace Aws