CodeArtifactClient.h

 
#pragma once
#include <aws/codeartifact/CodeArtifact_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/codeartifact/CodeArtifactServiceClientModel.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