CodeArtifactClient.h

 
#pragma once
#include <aws/codeartifact/CodeArtifactServiceClientModel.h>
#include <aws/codeartifact/CodeArtifact_EXPORTS.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
 
namespace Aws {
namespace CodeArtifact {
class AWS_CODEARTIFACT_API CodeArtifactClient : public Aws::Client::AWSJsonClient,
                                                public Aws::Client::ClientWithAsyncTemplateMethods<CodeArtifactClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef CodeArtifactClientConfiguration ClientConfigurationType;
  typedef CodeArtifactEndpointProvider EndpointProviderType;
 
  CodeArtifactClient(
      const Aws::CodeArtifact::CodeArtifactClientConfiguration& clientConfiguration = Aws::CodeArtifact::CodeArtifactClientConfiguration(),
      std::shared_ptr<CodeArtifactEndpointProviderBase> endpointProvider = nullptr);
 
  CodeArtifactClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<CodeArtifactEndpointProviderBase> endpointProvider = nullptr,
      const Aws::CodeArtifact::CodeArtifactClientConfiguration& clientConfiguration = Aws::CodeArtifact::CodeArtifactClientConfiguration());
 
  CodeArtifactClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<CodeArtifactEndpointProviderBase> endpointProvider = nullptr,
      const Aws::CodeArtifact::CodeArtifactClientConfiguration& clientConfiguration = Aws::CodeArtifact::CodeArtifactClientConfiguration());
 
  /* Legacy constructors due deprecation */
  CodeArtifactClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CodeArtifactClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CodeArtifactClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~CodeArtifactClient();
 
  virtual Model::AssociateExternalConnectionOutcome AssociateExternalConnection(
      const Model::AssociateExternalConnectionRequest& request) const;
 
  template <typename AssociateExternalConnectionRequestT = Model::AssociateExternalConnectionRequest>
  Model::AssociateExternalConnectionOutcomeCallable AssociateExternalConnectionCallable(
      const AssociateExternalConnectionRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::AssociateExternalConnection, request);
  }
 
  template <typename AssociateExternalConnectionRequestT = Model::AssociateExternalConnectionRequest>
  void AssociateExternalConnectionAsync(const AssociateExternalConnectionRequestT& request,
                                        const AssociateExternalConnectionResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::AssociateExternalConnection, request, handler, context);
  }
 
  virtual Model::CopyPackageVersionsOutcome CopyPackageVersions(const Model::CopyPackageVersionsRequest& request) const;
 
  template <typename CopyPackageVersionsRequestT = Model::CopyPackageVersionsRequest>
  Model::CopyPackageVersionsOutcomeCallable CopyPackageVersionsCallable(const CopyPackageVersionsRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::CopyPackageVersions, request);
  }
 
  template <typename CopyPackageVersionsRequestT = Model::CopyPackageVersionsRequest>
  void CopyPackageVersionsAsync(const CopyPackageVersionsRequestT& request, const CopyPackageVersionsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::CopyPackageVersions, request, handler, context);
  }
 
  virtual Model::CreateDomainOutcome CreateDomain(const Model::CreateDomainRequest& request) const;
 
  template <typename CreateDomainRequestT = Model::CreateDomainRequest>
  Model::CreateDomainOutcomeCallable CreateDomainCallable(const CreateDomainRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::CreateDomain, request);
  }
 
  template <typename CreateDomainRequestT = Model::CreateDomainRequest>
  void CreateDomainAsync(const CreateDomainRequestT& request, const CreateDomainResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::CreateDomain, request, handler, context);
  }
 
  virtual Model::CreatePackageGroupOutcome CreatePackageGroup(const Model::CreatePackageGroupRequest& request) const;
 
  template <typename CreatePackageGroupRequestT = Model::CreatePackageGroupRequest>
  Model::CreatePackageGroupOutcomeCallable CreatePackageGroupCallable(const CreatePackageGroupRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::CreatePackageGroup, request);
  }
 
  template <typename CreatePackageGroupRequestT = Model::CreatePackageGroupRequest>
  void CreatePackageGroupAsync(const CreatePackageGroupRequestT& request, const CreatePackageGroupResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::CreatePackageGroup, request, handler, context);
  }
 
  virtual Model::CreateRepositoryOutcome CreateRepository(const Model::CreateRepositoryRequest& request) const;
 
  template <typename CreateRepositoryRequestT = Model::CreateRepositoryRequest>
  Model::CreateRepositoryOutcomeCallable CreateRepositoryCallable(const CreateRepositoryRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::CreateRepository, request);
  }
 
  template <typename CreateRepositoryRequestT = Model::CreateRepositoryRequest>
  void CreateRepositoryAsync(const CreateRepositoryRequestT& request, const CreateRepositoryResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::CreateRepository, request, handler, context);
  }
 
  virtual Model::DeleteDomainOutcome DeleteDomain(const Model::DeleteDomainRequest& request) const;
 
  template <typename DeleteDomainRequestT = Model::DeleteDomainRequest>
  Model::DeleteDomainOutcomeCallable DeleteDomainCallable(const DeleteDomainRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::DeleteDomain, request);
  }
 
  template <typename DeleteDomainRequestT = Model::DeleteDomainRequest>
  void DeleteDomainAsync(const DeleteDomainRequestT& request, const DeleteDomainResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::DeleteDomain, request, handler, context);
  }
 
  virtual Model::DeleteDomainPermissionsPolicyOutcome DeleteDomainPermissionsPolicy(
      const Model::DeleteDomainPermissionsPolicyRequest& request) const;
 
  template <typename DeleteDomainPermissionsPolicyRequestT = Model::DeleteDomainPermissionsPolicyRequest>
  Model::DeleteDomainPermissionsPolicyOutcomeCallable DeleteDomainPermissionsPolicyCallable(
      const DeleteDomainPermissionsPolicyRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::DeleteDomainPermissionsPolicy, request);
  }
 
  template <typename DeleteDomainPermissionsPolicyRequestT = Model::DeleteDomainPermissionsPolicyRequest>
  void DeleteDomainPermissionsPolicyAsync(const DeleteDomainPermissionsPolicyRequestT& request,
                                          const DeleteDomainPermissionsPolicyResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::DeleteDomainPermissionsPolicy, request, handler, context);
  }
 
  virtual Model::DeletePackageOutcome DeletePackage(const Model::DeletePackageRequest& request) const;
 
  template <typename DeletePackageRequestT = Model::DeletePackageRequest>
  Model::DeletePackageOutcomeCallable DeletePackageCallable(const DeletePackageRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::DeletePackage, request);
  }
 
  template <typename DeletePackageRequestT = Model::DeletePackageRequest>
  void DeletePackageAsync(const DeletePackageRequestT& request, const DeletePackageResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::DeletePackage, request, handler, context);
  }
 
  virtual Model::DeletePackageGroupOutcome DeletePackageGroup(const Model::DeletePackageGroupRequest& request) const;
 
  template <typename DeletePackageGroupRequestT = Model::DeletePackageGroupRequest>
  Model::DeletePackageGroupOutcomeCallable DeletePackageGroupCallable(const DeletePackageGroupRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::DeletePackageGroup, request);
  }
 
  template <typename DeletePackageGroupRequestT = Model::DeletePackageGroupRequest>
  void DeletePackageGroupAsync(const DeletePackageGroupRequestT& request, const DeletePackageGroupResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::DeletePackageGroup, request, handler, context);
  }
 
  virtual Model::DeletePackageVersionsOutcome DeletePackageVersions(const Model::DeletePackageVersionsRequest& request) const;
 
  template <typename DeletePackageVersionsRequestT = Model::DeletePackageVersionsRequest>
  Model::DeletePackageVersionsOutcomeCallable DeletePackageVersionsCallable(const DeletePackageVersionsRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::DeletePackageVersions, request);
  }
 
  template <typename DeletePackageVersionsRequestT = Model::DeletePackageVersionsRequest>
  void DeletePackageVersionsAsync(const DeletePackageVersionsRequestT& request, const DeletePackageVersionsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::DeletePackageVersions, request, handler, context);
  }
 
  virtual Model::DeleteRepositoryOutcome DeleteRepository(const Model::DeleteRepositoryRequest& request) const;
 
  template <typename DeleteRepositoryRequestT = Model::DeleteRepositoryRequest>
  Model::DeleteRepositoryOutcomeCallable DeleteRepositoryCallable(const DeleteRepositoryRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::DeleteRepository, request);
  }
 
  template <typename DeleteRepositoryRequestT = Model::DeleteRepositoryRequest>
  void DeleteRepositoryAsync(const DeleteRepositoryRequestT& request, const DeleteRepositoryResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::DeleteRepository, request, handler, context);
  }
 
  virtual Model::DeleteRepositoryPermissionsPolicyOutcome DeleteRepositoryPermissionsPolicy(
      const Model::DeleteRepositoryPermissionsPolicyRequest& request) const;
 
  template <typename DeleteRepositoryPermissionsPolicyRequestT = Model::DeleteRepositoryPermissionsPolicyRequest>
  Model::DeleteRepositoryPermissionsPolicyOutcomeCallable DeleteRepositoryPermissionsPolicyCallable(
      const DeleteRepositoryPermissionsPolicyRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::DeleteRepositoryPermissionsPolicy, request);
  }
 
  template <typename DeleteRepositoryPermissionsPolicyRequestT = Model::DeleteRepositoryPermissionsPolicyRequest>
  void DeleteRepositoryPermissionsPolicyAsync(const DeleteRepositoryPermissionsPolicyRequestT& request,
                                              const DeleteRepositoryPermissionsPolicyResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::DeleteRepositoryPermissionsPolicy, request, handler, context);
  }
 
  virtual Model::DescribeDomainOutcome DescribeDomain(const Model::DescribeDomainRequest& request) const;
 
  template <typename DescribeDomainRequestT = Model::DescribeDomainRequest>
  Model::DescribeDomainOutcomeCallable DescribeDomainCallable(const DescribeDomainRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::DescribeDomain, request);
  }
 
  template <typename DescribeDomainRequestT = Model::DescribeDomainRequest>
  void DescribeDomainAsync(const DescribeDomainRequestT& request, const DescribeDomainResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::DescribeDomain, request, handler, context);
  }
 
  virtual Model::DescribePackageOutcome DescribePackage(const Model::DescribePackageRequest& request) const;
 
  template <typename DescribePackageRequestT = Model::DescribePackageRequest>
  Model::DescribePackageOutcomeCallable DescribePackageCallable(const DescribePackageRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::DescribePackage, request);
  }
 
  template <typename DescribePackageRequestT = Model::DescribePackageRequest>
  void DescribePackageAsync(const DescribePackageRequestT& request, const DescribePackageResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::DescribePackage, request, handler, context);
  }
 
  virtual Model::DescribePackageGroupOutcome DescribePackageGroup(const Model::DescribePackageGroupRequest& request) const;
 
  template <typename DescribePackageGroupRequestT = Model::DescribePackageGroupRequest>
  Model::DescribePackageGroupOutcomeCallable DescribePackageGroupCallable(const DescribePackageGroupRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::DescribePackageGroup, request);
  }
 
  template <typename DescribePackageGroupRequestT = Model::DescribePackageGroupRequest>
  void DescribePackageGroupAsync(const DescribePackageGroupRequestT& request, const DescribePackageGroupResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::DescribePackageGroup, request, handler, context);
  }
 
  virtual Model::DescribePackageVersionOutcome DescribePackageVersion(const Model::DescribePackageVersionRequest& request) const;
 
  template <typename DescribePackageVersionRequestT = Model::DescribePackageVersionRequest>
  Model::DescribePackageVersionOutcomeCallable DescribePackageVersionCallable(const DescribePackageVersionRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::DescribePackageVersion, request);
  }
 
  template <typename DescribePackageVersionRequestT = Model::DescribePackageVersionRequest>
  void DescribePackageVersionAsync(const DescribePackageVersionRequestT& request,
                                   const DescribePackageVersionResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::DescribePackageVersion, request, handler, context);
  }
 
  virtual Model::DescribeRepositoryOutcome DescribeRepository(const Model::DescribeRepositoryRequest& request) const;
 
  template <typename DescribeRepositoryRequestT = Model::DescribeRepositoryRequest>
  Model::DescribeRepositoryOutcomeCallable DescribeRepositoryCallable(const DescribeRepositoryRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::DescribeRepository, request);
  }
 
  template <typename DescribeRepositoryRequestT = Model::DescribeRepositoryRequest>
  void DescribeRepositoryAsync(const DescribeRepositoryRequestT& request, const DescribeRepositoryResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::DescribeRepository, request, handler, context);
  }
 
  virtual Model::DisassociateExternalConnectionOutcome DisassociateExternalConnection(
      const Model::DisassociateExternalConnectionRequest& request) const;
 
  template <typename DisassociateExternalConnectionRequestT = Model::DisassociateExternalConnectionRequest>
  Model::DisassociateExternalConnectionOutcomeCallable DisassociateExternalConnectionCallable(
      const DisassociateExternalConnectionRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::DisassociateExternalConnection, request);
  }
 
  template <typename DisassociateExternalConnectionRequestT = Model::DisassociateExternalConnectionRequest>
  void DisassociateExternalConnectionAsync(const DisassociateExternalConnectionRequestT& request,
                                           const DisassociateExternalConnectionResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::DisassociateExternalConnection, request, handler, context);
  }
 
  virtual Model::DisposePackageVersionsOutcome DisposePackageVersions(const Model::DisposePackageVersionsRequest& request) const;
 
  template <typename DisposePackageVersionsRequestT = Model::DisposePackageVersionsRequest>
  Model::DisposePackageVersionsOutcomeCallable DisposePackageVersionsCallable(const DisposePackageVersionsRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::DisposePackageVersions, request);
  }
 
  template <typename DisposePackageVersionsRequestT = Model::DisposePackageVersionsRequest>
  void DisposePackageVersionsAsync(const DisposePackageVersionsRequestT& request,
                                   const DisposePackageVersionsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::DisposePackageVersions, request, handler, context);
  }
 
  virtual Model::GetAssociatedPackageGroupOutcome GetAssociatedPackageGroup(const Model::GetAssociatedPackageGroupRequest& request) const;
 
  template <typename GetAssociatedPackageGroupRequestT = Model::GetAssociatedPackageGroupRequest>
  Model::GetAssociatedPackageGroupOutcomeCallable GetAssociatedPackageGroupCallable(
      const GetAssociatedPackageGroupRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::GetAssociatedPackageGroup, request);
  }
 
  template <typename GetAssociatedPackageGroupRequestT = Model::GetAssociatedPackageGroupRequest>
  void GetAssociatedPackageGroupAsync(const GetAssociatedPackageGroupRequestT& request,
                                      const GetAssociatedPackageGroupResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::GetAssociatedPackageGroup, request, handler, context);
  }
 
  virtual Model::GetAuthorizationTokenOutcome GetAuthorizationToken(const Model::GetAuthorizationTokenRequest& request) const;
 
  template <typename GetAuthorizationTokenRequestT = Model::GetAuthorizationTokenRequest>
  Model::GetAuthorizationTokenOutcomeCallable GetAuthorizationTokenCallable(const GetAuthorizationTokenRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::GetAuthorizationToken, request);
  }
 
  template <typename GetAuthorizationTokenRequestT = Model::GetAuthorizationTokenRequest>
  void GetAuthorizationTokenAsync(const GetAuthorizationTokenRequestT& request, const GetAuthorizationTokenResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::GetAuthorizationToken, request, handler, context);
  }
 
  virtual Model::GetDomainPermissionsPolicyOutcome GetDomainPermissionsPolicy(
      const Model::GetDomainPermissionsPolicyRequest& request) const;
 
  template <typename GetDomainPermissionsPolicyRequestT = Model::GetDomainPermissionsPolicyRequest>
  Model::GetDomainPermissionsPolicyOutcomeCallable GetDomainPermissionsPolicyCallable(
      const GetDomainPermissionsPolicyRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::GetDomainPermissionsPolicy, request);
  }
 
  template <typename GetDomainPermissionsPolicyRequestT = Model::GetDomainPermissionsPolicyRequest>
  void GetDomainPermissionsPolicyAsync(const GetDomainPermissionsPolicyRequestT& request,
                                       const GetDomainPermissionsPolicyResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::GetDomainPermissionsPolicy, request, handler, context);
  }
 
  virtual Model::GetPackageVersionAssetOutcome GetPackageVersionAsset(const Model::GetPackageVersionAssetRequest& request) const;
 
  template <typename GetPackageVersionAssetRequestT = Model::GetPackageVersionAssetRequest>
  Model::GetPackageVersionAssetOutcomeCallable GetPackageVersionAssetCallable(const GetPackageVersionAssetRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::GetPackageVersionAsset, request);
  }
 
  template <typename GetPackageVersionAssetRequestT = Model::GetPackageVersionAssetRequest>
  void GetPackageVersionAssetAsync(const GetPackageVersionAssetRequestT& request,
                                   const GetPackageVersionAssetResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::GetPackageVersionAsset, request, handler, context);
  }
 
  virtual Model::GetPackageVersionReadmeOutcome GetPackageVersionReadme(const Model::GetPackageVersionReadmeRequest& request) const;
 
  template <typename GetPackageVersionReadmeRequestT = Model::GetPackageVersionReadmeRequest>
  Model::GetPackageVersionReadmeOutcomeCallable GetPackageVersionReadmeCallable(const GetPackageVersionReadmeRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::GetPackageVersionReadme, request);
  }
 
  template <typename GetPackageVersionReadmeRequestT = Model::GetPackageVersionReadmeRequest>
  void GetPackageVersionReadmeAsync(const GetPackageVersionReadmeRequestT& request,
                                    const GetPackageVersionReadmeResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::GetPackageVersionReadme, request, handler, context);
  }
 
  virtual Model::GetRepositoryEndpointOutcome GetRepositoryEndpoint(const Model::GetRepositoryEndpointRequest& request) const;
 
  template <typename GetRepositoryEndpointRequestT = Model::GetRepositoryEndpointRequest>
  Model::GetRepositoryEndpointOutcomeCallable GetRepositoryEndpointCallable(const GetRepositoryEndpointRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::GetRepositoryEndpoint, request);
  }
 
  template <typename GetRepositoryEndpointRequestT = Model::GetRepositoryEndpointRequest>
  void GetRepositoryEndpointAsync(const GetRepositoryEndpointRequestT& request, const GetRepositoryEndpointResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::GetRepositoryEndpoint, request, handler, context);
  }
 
  virtual Model::GetRepositoryPermissionsPolicyOutcome GetRepositoryPermissionsPolicy(
      const Model::GetRepositoryPermissionsPolicyRequest& request) const;
 
  template <typename GetRepositoryPermissionsPolicyRequestT = Model::GetRepositoryPermissionsPolicyRequest>
  Model::GetRepositoryPermissionsPolicyOutcomeCallable GetRepositoryPermissionsPolicyCallable(
      const GetRepositoryPermissionsPolicyRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::GetRepositoryPermissionsPolicy, request);
  }
 
  template <typename GetRepositoryPermissionsPolicyRequestT = Model::GetRepositoryPermissionsPolicyRequest>
  void GetRepositoryPermissionsPolicyAsync(const GetRepositoryPermissionsPolicyRequestT& request,
                                           const GetRepositoryPermissionsPolicyResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::GetRepositoryPermissionsPolicy, request, handler, context);
  }
 
  virtual Model::ListAllowedRepositoriesForGroupOutcome ListAllowedRepositoriesForGroup(
      const Model::ListAllowedRepositoriesForGroupRequest& request) const;
 
  template <typename ListAllowedRepositoriesForGroupRequestT = Model::ListAllowedRepositoriesForGroupRequest>
  Model::ListAllowedRepositoriesForGroupOutcomeCallable ListAllowedRepositoriesForGroupCallable(
      const ListAllowedRepositoriesForGroupRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::ListAllowedRepositoriesForGroup, request);
  }
 
  template <typename ListAllowedRepositoriesForGroupRequestT = Model::ListAllowedRepositoriesForGroupRequest>
  void ListAllowedRepositoriesForGroupAsync(const ListAllowedRepositoriesForGroupRequestT& request,
                                            const ListAllowedRepositoriesForGroupResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::ListAllowedRepositoriesForGroup, request, handler, context);
  }
 
  virtual Model::ListAssociatedPackagesOutcome ListAssociatedPackages(const Model::ListAssociatedPackagesRequest& request) const;
 
  template <typename ListAssociatedPackagesRequestT = Model::ListAssociatedPackagesRequest>
  Model::ListAssociatedPackagesOutcomeCallable ListAssociatedPackagesCallable(const ListAssociatedPackagesRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::ListAssociatedPackages, request);
  }
 
  template <typename ListAssociatedPackagesRequestT = Model::ListAssociatedPackagesRequest>
  void ListAssociatedPackagesAsync(const ListAssociatedPackagesRequestT& request,
                                   const ListAssociatedPackagesResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::ListAssociatedPackages, request, handler, context);
  }
 
  virtual Model::ListDomainsOutcome ListDomains(const Model::ListDomainsRequest& request = {}) const;
 
  template <typename ListDomainsRequestT = Model::ListDomainsRequest>
  Model::ListDomainsOutcomeCallable ListDomainsCallable(const ListDomainsRequestT& request = {}) const {
    return SubmitCallable(&CodeArtifactClient::ListDomains, request);
  }
 
  template <typename ListDomainsRequestT = Model::ListDomainsRequest>
  void ListDomainsAsync(const ListDomainsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListDomainsRequestT& request = {}) const {
    return SubmitAsync(&CodeArtifactClient::ListDomains, request, handler, context);
  }
 
  virtual Model::ListPackageGroupsOutcome ListPackageGroups(const Model::ListPackageGroupsRequest& request) const;
 
  template <typename ListPackageGroupsRequestT = Model::ListPackageGroupsRequest>
  Model::ListPackageGroupsOutcomeCallable ListPackageGroupsCallable(const ListPackageGroupsRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::ListPackageGroups, request);
  }
 
  template <typename ListPackageGroupsRequestT = Model::ListPackageGroupsRequest>
  void ListPackageGroupsAsync(const ListPackageGroupsRequestT& request, const ListPackageGroupsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::ListPackageGroups, request, handler, context);
  }
 
  virtual Model::ListPackageVersionAssetsOutcome ListPackageVersionAssets(const Model::ListPackageVersionAssetsRequest& request) const;
 
  template <typename ListPackageVersionAssetsRequestT = Model::ListPackageVersionAssetsRequest>
  Model::ListPackageVersionAssetsOutcomeCallable ListPackageVersionAssetsCallable(const ListPackageVersionAssetsRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::ListPackageVersionAssets, request);
  }
 
  template <typename ListPackageVersionAssetsRequestT = Model::ListPackageVersionAssetsRequest>
  void ListPackageVersionAssetsAsync(const ListPackageVersionAssetsRequestT& request,
                                     const ListPackageVersionAssetsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::ListPackageVersionAssets, request, handler, context);
  }
 
  virtual Model::ListPackageVersionDependenciesOutcome ListPackageVersionDependencies(
      const Model::ListPackageVersionDependenciesRequest& request) const;
 
  template <typename ListPackageVersionDependenciesRequestT = Model::ListPackageVersionDependenciesRequest>
  Model::ListPackageVersionDependenciesOutcomeCallable ListPackageVersionDependenciesCallable(
      const ListPackageVersionDependenciesRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::ListPackageVersionDependencies, request);
  }
 
  template <typename ListPackageVersionDependenciesRequestT = Model::ListPackageVersionDependenciesRequest>
  void ListPackageVersionDependenciesAsync(const ListPackageVersionDependenciesRequestT& request,
                                           const ListPackageVersionDependenciesResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::ListPackageVersionDependencies, request, handler, context);
  }
 
  virtual Model::ListPackageVersionsOutcome ListPackageVersions(const Model::ListPackageVersionsRequest& request) const;
 
  template <typename ListPackageVersionsRequestT = Model::ListPackageVersionsRequest>
  Model::ListPackageVersionsOutcomeCallable ListPackageVersionsCallable(const ListPackageVersionsRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::ListPackageVersions, request);
  }
 
  template <typename ListPackageVersionsRequestT = Model::ListPackageVersionsRequest>
  void ListPackageVersionsAsync(const ListPackageVersionsRequestT& request, const ListPackageVersionsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::ListPackageVersions, request, handler, context);
  }
 
  virtual Model::ListPackagesOutcome ListPackages(const Model::ListPackagesRequest& request) const;
 
  template <typename ListPackagesRequestT = Model::ListPackagesRequest>
  Model::ListPackagesOutcomeCallable ListPackagesCallable(const ListPackagesRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::ListPackages, request);
  }
 
  template <typename ListPackagesRequestT = Model::ListPackagesRequest>
  void ListPackagesAsync(const ListPackagesRequestT& request, const ListPackagesResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::ListPackages, request, handler, context);
  }
 
  virtual Model::ListRepositoriesOutcome ListRepositories(const Model::ListRepositoriesRequest& request = {}) const;
 
  template <typename ListRepositoriesRequestT = Model::ListRepositoriesRequest>
  Model::ListRepositoriesOutcomeCallable ListRepositoriesCallable(const ListRepositoriesRequestT& request = {}) const {
    return SubmitCallable(&CodeArtifactClient::ListRepositories, request);
  }
 
  template <typename ListRepositoriesRequestT = Model::ListRepositoriesRequest>
  void ListRepositoriesAsync(const ListRepositoriesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListRepositoriesRequestT& request = {}) const {
    return SubmitAsync(&CodeArtifactClient::ListRepositories, request, handler, context);
  }
 
  virtual Model::ListRepositoriesInDomainOutcome ListRepositoriesInDomain(const Model::ListRepositoriesInDomainRequest& request) const;
 
  template <typename ListRepositoriesInDomainRequestT = Model::ListRepositoriesInDomainRequest>
  Model::ListRepositoriesInDomainOutcomeCallable ListRepositoriesInDomainCallable(const ListRepositoriesInDomainRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::ListRepositoriesInDomain, request);
  }
 
  template <typename ListRepositoriesInDomainRequestT = Model::ListRepositoriesInDomainRequest>
  void ListRepositoriesInDomainAsync(const ListRepositoriesInDomainRequestT& request,
                                     const ListRepositoriesInDomainResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::ListRepositoriesInDomain, request, handler, context);
  }
 
  virtual Model::ListSubPackageGroupsOutcome ListSubPackageGroups(const Model::ListSubPackageGroupsRequest& request) const;
 
  template <typename ListSubPackageGroupsRequestT = Model::ListSubPackageGroupsRequest>
  Model::ListSubPackageGroupsOutcomeCallable ListSubPackageGroupsCallable(const ListSubPackageGroupsRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::ListSubPackageGroups, request);
  }
 
  template <typename ListSubPackageGroupsRequestT = Model::ListSubPackageGroupsRequest>
  void ListSubPackageGroupsAsync(const ListSubPackageGroupsRequestT& request, const ListSubPackageGroupsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::ListSubPackageGroups, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::PublishPackageVersionOutcome PublishPackageVersion(const Model::PublishPackageVersionRequest& request) const;
 
  template <typename PublishPackageVersionRequestT = Model::PublishPackageVersionRequest>
  Model::PublishPackageVersionOutcomeCallable PublishPackageVersionCallable(const PublishPackageVersionRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::PublishPackageVersion, request);
  }
 
  template <typename PublishPackageVersionRequestT = Model::PublishPackageVersionRequest>
  void PublishPackageVersionAsync(const PublishPackageVersionRequestT& request, const PublishPackageVersionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::PublishPackageVersion, request, handler, context);
  }
 
  virtual Model::PutDomainPermissionsPolicyOutcome PutDomainPermissionsPolicy(
      const Model::PutDomainPermissionsPolicyRequest& request) const;
 
  template <typename PutDomainPermissionsPolicyRequestT = Model::PutDomainPermissionsPolicyRequest>
  Model::PutDomainPermissionsPolicyOutcomeCallable PutDomainPermissionsPolicyCallable(
      const PutDomainPermissionsPolicyRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::PutDomainPermissionsPolicy, request);
  }
 
  template <typename PutDomainPermissionsPolicyRequestT = Model::PutDomainPermissionsPolicyRequest>
  void PutDomainPermissionsPolicyAsync(const PutDomainPermissionsPolicyRequestT& request,
                                       const PutDomainPermissionsPolicyResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::PutDomainPermissionsPolicy, request, handler, context);
  }
 
  virtual Model::PutPackageOriginConfigurationOutcome PutPackageOriginConfiguration(
      const Model::PutPackageOriginConfigurationRequest& request) const;
 
  template <typename PutPackageOriginConfigurationRequestT = Model::PutPackageOriginConfigurationRequest>
  Model::PutPackageOriginConfigurationOutcomeCallable PutPackageOriginConfigurationCallable(
      const PutPackageOriginConfigurationRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::PutPackageOriginConfiguration, request);
  }
 
  template <typename PutPackageOriginConfigurationRequestT = Model::PutPackageOriginConfigurationRequest>
  void PutPackageOriginConfigurationAsync(const PutPackageOriginConfigurationRequestT& request,
                                          const PutPackageOriginConfigurationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::PutPackageOriginConfiguration, request, handler, context);
  }
 
  virtual Model::PutRepositoryPermissionsPolicyOutcome PutRepositoryPermissionsPolicy(
      const Model::PutRepositoryPermissionsPolicyRequest& request) const;
 
  template <typename PutRepositoryPermissionsPolicyRequestT = Model::PutRepositoryPermissionsPolicyRequest>
  Model::PutRepositoryPermissionsPolicyOutcomeCallable PutRepositoryPermissionsPolicyCallable(
      const PutRepositoryPermissionsPolicyRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::PutRepositoryPermissionsPolicy, request);
  }
 
  template <typename PutRepositoryPermissionsPolicyRequestT = Model::PutRepositoryPermissionsPolicyRequest>
  void PutRepositoryPermissionsPolicyAsync(const PutRepositoryPermissionsPolicyRequestT& request,
                                           const PutRepositoryPermissionsPolicyResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::PutRepositoryPermissionsPolicy, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdatePackageGroupOutcome UpdatePackageGroup(const Model::UpdatePackageGroupRequest& request) const;
 
  template <typename UpdatePackageGroupRequestT = Model::UpdatePackageGroupRequest>
  Model::UpdatePackageGroupOutcomeCallable UpdatePackageGroupCallable(const UpdatePackageGroupRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::UpdatePackageGroup, request);
  }
 
  template <typename UpdatePackageGroupRequestT = Model::UpdatePackageGroupRequest>
  void UpdatePackageGroupAsync(const UpdatePackageGroupRequestT& request, const UpdatePackageGroupResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::UpdatePackageGroup, request, handler, context);
  }
 
  virtual Model::UpdatePackageGroupOriginConfigurationOutcome UpdatePackageGroupOriginConfiguration(
      const Model::UpdatePackageGroupOriginConfigurationRequest& request) const;
 
  template <typename UpdatePackageGroupOriginConfigurationRequestT = Model::UpdatePackageGroupOriginConfigurationRequest>
  Model::UpdatePackageGroupOriginConfigurationOutcomeCallable UpdatePackageGroupOriginConfigurationCallable(
      const UpdatePackageGroupOriginConfigurationRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::UpdatePackageGroupOriginConfiguration, request);
  }
 
  template <typename UpdatePackageGroupOriginConfigurationRequestT = Model::UpdatePackageGroupOriginConfigurationRequest>
  void UpdatePackageGroupOriginConfigurationAsync(const UpdatePackageGroupOriginConfigurationRequestT& request,
                                                  const UpdatePackageGroupOriginConfigurationResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::UpdatePackageGroupOriginConfiguration, request, handler, context);
  }
 
  virtual Model::UpdatePackageVersionsStatusOutcome UpdatePackageVersionsStatus(
      const Model::UpdatePackageVersionsStatusRequest& request) const;
 
  template <typename UpdatePackageVersionsStatusRequestT = Model::UpdatePackageVersionsStatusRequest>
  Model::UpdatePackageVersionsStatusOutcomeCallable UpdatePackageVersionsStatusCallable(
      const UpdatePackageVersionsStatusRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::UpdatePackageVersionsStatus, request);
  }
 
  template <typename UpdatePackageVersionsStatusRequestT = Model::UpdatePackageVersionsStatusRequest>
  void UpdatePackageVersionsStatusAsync(const UpdatePackageVersionsStatusRequestT& request,
                                        const UpdatePackageVersionsStatusResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::UpdatePackageVersionsStatus, request, handler, context);
  }
 
  virtual Model::UpdateRepositoryOutcome UpdateRepository(const Model::UpdateRepositoryRequest& request) const;
 
  template <typename UpdateRepositoryRequestT = Model::UpdateRepositoryRequest>
  Model::UpdateRepositoryOutcomeCallable UpdateRepositoryCallable(const UpdateRepositoryRequestT& request) const {
    return SubmitCallable(&CodeArtifactClient::UpdateRepository, request);
  }
 
  template <typename UpdateRepositoryRequestT = Model::UpdateRepositoryRequest>
  void UpdateRepositoryAsync(const UpdateRepositoryRequestT& request, const UpdateRepositoryResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeArtifactClient::UpdateRepository, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<CodeArtifactEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<CodeArtifactClient>;
  void init(const CodeArtifactClientConfiguration& clientConfiguration);
 
  CodeArtifactClientConfiguration m_clientConfiguration;
  std::shared_ptr<CodeArtifactEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace CodeArtifact
}  // namespace Aws