CodeDeployClient.h

 
#pragma once
#include <aws/codedeploy/CodeDeploy_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/codedeploy/CodeDeployServiceClientModel.h>
 
namespace Aws
{
namespace CodeDeploy
{
  class AWS_CODEDEPLOY_API CodeDeployClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<CodeDeployClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef CodeDeployClientConfiguration ClientConfigurationType;
      typedef CodeDeployEndpointProvider EndpointProviderType;
 
        CodeDeployClient(const Aws::CodeDeploy::CodeDeployClientConfiguration& clientConfiguration = Aws::CodeDeploy::CodeDeployClientConfiguration(),
                         std::shared_ptr<CodeDeployEndpointProviderBase> endpointProvider = nullptr);
 
        CodeDeployClient(const Aws::Auth::AWSCredentials& credentials,
                         std::shared_ptr<CodeDeployEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::CodeDeploy::CodeDeployClientConfiguration& clientConfiguration = Aws::CodeDeploy::CodeDeployClientConfiguration());
 
        CodeDeployClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         std::shared_ptr<CodeDeployEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::CodeDeploy::CodeDeployClientConfiguration& clientConfiguration = Aws::CodeDeploy::CodeDeployClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        CodeDeployClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        CodeDeployClient(const Aws::Auth::AWSCredentials& credentials,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
        CodeDeployClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~CodeDeployClient();
 
        virtual Model::AddTagsToOnPremisesInstancesOutcome AddTagsToOnPremisesInstances(const Model::AddTagsToOnPremisesInstancesRequest& request) const;
 
        template<typename AddTagsToOnPremisesInstancesRequestT = Model::AddTagsToOnPremisesInstancesRequest>
        Model::AddTagsToOnPremisesInstancesOutcomeCallable AddTagsToOnPremisesInstancesCallable(const AddTagsToOnPremisesInstancesRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::AddTagsToOnPremisesInstances, request);
        }
 
        template<typename AddTagsToOnPremisesInstancesRequestT = Model::AddTagsToOnPremisesInstancesRequest>
        void AddTagsToOnPremisesInstancesAsync(const AddTagsToOnPremisesInstancesRequestT& request, const AddTagsToOnPremisesInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::AddTagsToOnPremisesInstances, request, handler, context);
        }
 
        virtual Model::BatchGetApplicationRevisionsOutcome BatchGetApplicationRevisions(const Model::BatchGetApplicationRevisionsRequest& request) const;
 
        template<typename BatchGetApplicationRevisionsRequestT = Model::BatchGetApplicationRevisionsRequest>
        Model::BatchGetApplicationRevisionsOutcomeCallable BatchGetApplicationRevisionsCallable(const BatchGetApplicationRevisionsRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::BatchGetApplicationRevisions, request);
        }
 
        template<typename BatchGetApplicationRevisionsRequestT = Model::BatchGetApplicationRevisionsRequest>
        void BatchGetApplicationRevisionsAsync(const BatchGetApplicationRevisionsRequestT& request, const BatchGetApplicationRevisionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::BatchGetApplicationRevisions, request, handler, context);
        }
 
        virtual Model::BatchGetApplicationsOutcome BatchGetApplications(const Model::BatchGetApplicationsRequest& request) const;
 
        template<typename BatchGetApplicationsRequestT = Model::BatchGetApplicationsRequest>
        Model::BatchGetApplicationsOutcomeCallable BatchGetApplicationsCallable(const BatchGetApplicationsRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::BatchGetApplications, request);
        }
 
        template<typename BatchGetApplicationsRequestT = Model::BatchGetApplicationsRequest>
        void BatchGetApplicationsAsync(const BatchGetApplicationsRequestT& request, const BatchGetApplicationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::BatchGetApplications, request, handler, context);
        }
 
        virtual Model::BatchGetDeploymentGroupsOutcome BatchGetDeploymentGroups(const Model::BatchGetDeploymentGroupsRequest& request) const;
 
        template<typename BatchGetDeploymentGroupsRequestT = Model::BatchGetDeploymentGroupsRequest>
        Model::BatchGetDeploymentGroupsOutcomeCallable BatchGetDeploymentGroupsCallable(const BatchGetDeploymentGroupsRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::BatchGetDeploymentGroups, request);
        }
 
        template<typename BatchGetDeploymentGroupsRequestT = Model::BatchGetDeploymentGroupsRequest>
        void BatchGetDeploymentGroupsAsync(const BatchGetDeploymentGroupsRequestT& request, const BatchGetDeploymentGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::BatchGetDeploymentGroups, request, handler, context);
        }
 
        virtual Model::BatchGetDeploymentTargetsOutcome BatchGetDeploymentTargets(const Model::BatchGetDeploymentTargetsRequest& request) const;
 
        template<typename BatchGetDeploymentTargetsRequestT = Model::BatchGetDeploymentTargetsRequest>
        Model::BatchGetDeploymentTargetsOutcomeCallable BatchGetDeploymentTargetsCallable(const BatchGetDeploymentTargetsRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::BatchGetDeploymentTargets, request);
        }
 
        template<typename BatchGetDeploymentTargetsRequestT = Model::BatchGetDeploymentTargetsRequest>
        void BatchGetDeploymentTargetsAsync(const BatchGetDeploymentTargetsRequestT& request, const BatchGetDeploymentTargetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::BatchGetDeploymentTargets, request, handler, context);
        }
 
        virtual Model::BatchGetDeploymentsOutcome BatchGetDeployments(const Model::BatchGetDeploymentsRequest& request) const;
 
        template<typename BatchGetDeploymentsRequestT = Model::BatchGetDeploymentsRequest>
        Model::BatchGetDeploymentsOutcomeCallable BatchGetDeploymentsCallable(const BatchGetDeploymentsRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::BatchGetDeployments, request);
        }
 
        template<typename BatchGetDeploymentsRequestT = Model::BatchGetDeploymentsRequest>
        void BatchGetDeploymentsAsync(const BatchGetDeploymentsRequestT& request, const BatchGetDeploymentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::BatchGetDeployments, request, handler, context);
        }
 
        virtual Model::BatchGetOnPremisesInstancesOutcome BatchGetOnPremisesInstances(const Model::BatchGetOnPremisesInstancesRequest& request) const;
 
        template<typename BatchGetOnPremisesInstancesRequestT = Model::BatchGetOnPremisesInstancesRequest>
        Model::BatchGetOnPremisesInstancesOutcomeCallable BatchGetOnPremisesInstancesCallable(const BatchGetOnPremisesInstancesRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::BatchGetOnPremisesInstances, request);
        }
 
        template<typename BatchGetOnPremisesInstancesRequestT = Model::BatchGetOnPremisesInstancesRequest>
        void BatchGetOnPremisesInstancesAsync(const BatchGetOnPremisesInstancesRequestT& request, const BatchGetOnPremisesInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::BatchGetOnPremisesInstances, request, handler, context);
        }
 
        virtual Model::ContinueDeploymentOutcome ContinueDeployment(const Model::ContinueDeploymentRequest& request = {}) const;
 
        template<typename ContinueDeploymentRequestT = Model::ContinueDeploymentRequest>
        Model::ContinueDeploymentOutcomeCallable ContinueDeploymentCallable(const ContinueDeploymentRequestT& request = {}) const
        {
            return SubmitCallable(&CodeDeployClient::ContinueDeployment, request);
        }
 
        template<typename ContinueDeploymentRequestT = Model::ContinueDeploymentRequest>
        void ContinueDeploymentAsync(const ContinueDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ContinueDeploymentRequestT& request = {}) const
        {
            return SubmitAsync(&CodeDeployClient::ContinueDeployment, request, handler, context);
        }
 
        virtual Model::CreateApplicationOutcome CreateApplication(const Model::CreateApplicationRequest& request) const;
 
        template<typename CreateApplicationRequestT = Model::CreateApplicationRequest>
        Model::CreateApplicationOutcomeCallable CreateApplicationCallable(const CreateApplicationRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::CreateApplication, request);
        }
 
        template<typename CreateApplicationRequestT = Model::CreateApplicationRequest>
        void CreateApplicationAsync(const CreateApplicationRequestT& request, const CreateApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::CreateApplication, request, handler, context);
        }
 
        virtual Model::CreateDeploymentOutcome CreateDeployment(const Model::CreateDeploymentRequest& request) const;
 
        template<typename CreateDeploymentRequestT = Model::CreateDeploymentRequest>
        Model::CreateDeploymentOutcomeCallable CreateDeploymentCallable(const CreateDeploymentRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::CreateDeployment, request);
        }
 
        template<typename CreateDeploymentRequestT = Model::CreateDeploymentRequest>
        void CreateDeploymentAsync(const CreateDeploymentRequestT& request, const CreateDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::CreateDeployment, request, handler, context);
        }
 
        virtual Model::CreateDeploymentConfigOutcome CreateDeploymentConfig(const Model::CreateDeploymentConfigRequest& request) const;
 
        template<typename CreateDeploymentConfigRequestT = Model::CreateDeploymentConfigRequest>
        Model::CreateDeploymentConfigOutcomeCallable CreateDeploymentConfigCallable(const CreateDeploymentConfigRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::CreateDeploymentConfig, request);
        }
 
        template<typename CreateDeploymentConfigRequestT = Model::CreateDeploymentConfigRequest>
        void CreateDeploymentConfigAsync(const CreateDeploymentConfigRequestT& request, const CreateDeploymentConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::CreateDeploymentConfig, request, handler, context);
        }
 
        virtual Model::CreateDeploymentGroupOutcome CreateDeploymentGroup(const Model::CreateDeploymentGroupRequest& request) const;
 
        template<typename CreateDeploymentGroupRequestT = Model::CreateDeploymentGroupRequest>
        Model::CreateDeploymentGroupOutcomeCallable CreateDeploymentGroupCallable(const CreateDeploymentGroupRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::CreateDeploymentGroup, request);
        }
 
        template<typename CreateDeploymentGroupRequestT = Model::CreateDeploymentGroupRequest>
        void CreateDeploymentGroupAsync(const CreateDeploymentGroupRequestT& request, const CreateDeploymentGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::CreateDeploymentGroup, request, handler, context);
        }
 
        virtual Model::DeleteApplicationOutcome DeleteApplication(const Model::DeleteApplicationRequest& request) const;
 
        template<typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
        Model::DeleteApplicationOutcomeCallable DeleteApplicationCallable(const DeleteApplicationRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::DeleteApplication, request);
        }
 
        template<typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
        void DeleteApplicationAsync(const DeleteApplicationRequestT& request, const DeleteApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::DeleteApplication, request, handler, context);
        }
 
        virtual Model::DeleteDeploymentConfigOutcome DeleteDeploymentConfig(const Model::DeleteDeploymentConfigRequest& request) const;
 
        template<typename DeleteDeploymentConfigRequestT = Model::DeleteDeploymentConfigRequest>
        Model::DeleteDeploymentConfigOutcomeCallable DeleteDeploymentConfigCallable(const DeleteDeploymentConfigRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::DeleteDeploymentConfig, request);
        }
 
        template<typename DeleteDeploymentConfigRequestT = Model::DeleteDeploymentConfigRequest>
        void DeleteDeploymentConfigAsync(const DeleteDeploymentConfigRequestT& request, const DeleteDeploymentConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::DeleteDeploymentConfig, request, handler, context);
        }
 
        virtual Model::DeleteDeploymentGroupOutcome DeleteDeploymentGroup(const Model::DeleteDeploymentGroupRequest& request) const;
 
        template<typename DeleteDeploymentGroupRequestT = Model::DeleteDeploymentGroupRequest>
        Model::DeleteDeploymentGroupOutcomeCallable DeleteDeploymentGroupCallable(const DeleteDeploymentGroupRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::DeleteDeploymentGroup, request);
        }
 
        template<typename DeleteDeploymentGroupRequestT = Model::DeleteDeploymentGroupRequest>
        void DeleteDeploymentGroupAsync(const DeleteDeploymentGroupRequestT& request, const DeleteDeploymentGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::DeleteDeploymentGroup, request, handler, context);
        }
 
        virtual Model::DeleteGitHubAccountTokenOutcome DeleteGitHubAccountToken(const Model::DeleteGitHubAccountTokenRequest& request = {}) const;
 
        template<typename DeleteGitHubAccountTokenRequestT = Model::DeleteGitHubAccountTokenRequest>
        Model::DeleteGitHubAccountTokenOutcomeCallable DeleteGitHubAccountTokenCallable(const DeleteGitHubAccountTokenRequestT& request = {}) const
        {
            return SubmitCallable(&CodeDeployClient::DeleteGitHubAccountToken, request);
        }
 
        template<typename DeleteGitHubAccountTokenRequestT = Model::DeleteGitHubAccountTokenRequest>
        void DeleteGitHubAccountTokenAsync(const DeleteGitHubAccountTokenResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteGitHubAccountTokenRequestT& request = {}) const
        {
            return SubmitAsync(&CodeDeployClient::DeleteGitHubAccountToken, request, handler, context);
        }
 
        virtual Model::DeleteResourcesByExternalIdOutcome DeleteResourcesByExternalId(const Model::DeleteResourcesByExternalIdRequest& request = {}) const;
 
        template<typename DeleteResourcesByExternalIdRequestT = Model::DeleteResourcesByExternalIdRequest>
        Model::DeleteResourcesByExternalIdOutcomeCallable DeleteResourcesByExternalIdCallable(const DeleteResourcesByExternalIdRequestT& request = {}) const
        {
            return SubmitCallable(&CodeDeployClient::DeleteResourcesByExternalId, request);
        }
 
        template<typename DeleteResourcesByExternalIdRequestT = Model::DeleteResourcesByExternalIdRequest>
        void DeleteResourcesByExternalIdAsync(const DeleteResourcesByExternalIdResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteResourcesByExternalIdRequestT& request = {}) const
        {
            return SubmitAsync(&CodeDeployClient::DeleteResourcesByExternalId, request, handler, context);
        }
 
        virtual Model::DeregisterOnPremisesInstanceOutcome DeregisterOnPremisesInstance(const Model::DeregisterOnPremisesInstanceRequest& request) const;
 
        template<typename DeregisterOnPremisesInstanceRequestT = Model::DeregisterOnPremisesInstanceRequest>
        Model::DeregisterOnPremisesInstanceOutcomeCallable DeregisterOnPremisesInstanceCallable(const DeregisterOnPremisesInstanceRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::DeregisterOnPremisesInstance, request);
        }
 
        template<typename DeregisterOnPremisesInstanceRequestT = Model::DeregisterOnPremisesInstanceRequest>
        void DeregisterOnPremisesInstanceAsync(const DeregisterOnPremisesInstanceRequestT& request, const DeregisterOnPremisesInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::DeregisterOnPremisesInstance, request, handler, context);
        }
 
        virtual Model::GetApplicationOutcome GetApplication(const Model::GetApplicationRequest& request) const;
 
        template<typename GetApplicationRequestT = Model::GetApplicationRequest>
        Model::GetApplicationOutcomeCallable GetApplicationCallable(const GetApplicationRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::GetApplication, request);
        }
 
        template<typename GetApplicationRequestT = Model::GetApplicationRequest>
        void GetApplicationAsync(const GetApplicationRequestT& request, const GetApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::GetApplication, request, handler, context);
        }
 
        virtual Model::GetApplicationRevisionOutcome GetApplicationRevision(const Model::GetApplicationRevisionRequest& request) const;
 
        template<typename GetApplicationRevisionRequestT = Model::GetApplicationRevisionRequest>
        Model::GetApplicationRevisionOutcomeCallable GetApplicationRevisionCallable(const GetApplicationRevisionRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::GetApplicationRevision, request);
        }
 
        template<typename GetApplicationRevisionRequestT = Model::GetApplicationRevisionRequest>
        void GetApplicationRevisionAsync(const GetApplicationRevisionRequestT& request, const GetApplicationRevisionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::GetApplicationRevision, request, handler, context);
        }
 
        virtual Model::GetDeploymentOutcome GetDeployment(const Model::GetDeploymentRequest& request) const;
 
        template<typename GetDeploymentRequestT = Model::GetDeploymentRequest>
        Model::GetDeploymentOutcomeCallable GetDeploymentCallable(const GetDeploymentRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::GetDeployment, request);
        }
 
        template<typename GetDeploymentRequestT = Model::GetDeploymentRequest>
        void GetDeploymentAsync(const GetDeploymentRequestT& request, const GetDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::GetDeployment, request, handler, context);
        }
 
        virtual Model::GetDeploymentConfigOutcome GetDeploymentConfig(const Model::GetDeploymentConfigRequest& request) const;
 
        template<typename GetDeploymentConfigRequestT = Model::GetDeploymentConfigRequest>
        Model::GetDeploymentConfigOutcomeCallable GetDeploymentConfigCallable(const GetDeploymentConfigRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::GetDeploymentConfig, request);
        }
 
        template<typename GetDeploymentConfigRequestT = Model::GetDeploymentConfigRequest>
        void GetDeploymentConfigAsync(const GetDeploymentConfigRequestT& request, const GetDeploymentConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::GetDeploymentConfig, request, handler, context);
        }
 
        virtual Model::GetDeploymentGroupOutcome GetDeploymentGroup(const Model::GetDeploymentGroupRequest& request) const;
 
        template<typename GetDeploymentGroupRequestT = Model::GetDeploymentGroupRequest>
        Model::GetDeploymentGroupOutcomeCallable GetDeploymentGroupCallable(const GetDeploymentGroupRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::GetDeploymentGroup, request);
        }
 
        template<typename GetDeploymentGroupRequestT = Model::GetDeploymentGroupRequest>
        void GetDeploymentGroupAsync(const GetDeploymentGroupRequestT& request, const GetDeploymentGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::GetDeploymentGroup, request, handler, context);
        }
 
        virtual Model::GetDeploymentTargetOutcome GetDeploymentTarget(const Model::GetDeploymentTargetRequest& request) const;
 
        template<typename GetDeploymentTargetRequestT = Model::GetDeploymentTargetRequest>
        Model::GetDeploymentTargetOutcomeCallable GetDeploymentTargetCallable(const GetDeploymentTargetRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::GetDeploymentTarget, request);
        }
 
        template<typename GetDeploymentTargetRequestT = Model::GetDeploymentTargetRequest>
        void GetDeploymentTargetAsync(const GetDeploymentTargetRequestT& request, const GetDeploymentTargetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::GetDeploymentTarget, request, handler, context);
        }
 
        virtual Model::GetOnPremisesInstanceOutcome GetOnPremisesInstance(const Model::GetOnPremisesInstanceRequest& request) const;
 
        template<typename GetOnPremisesInstanceRequestT = Model::GetOnPremisesInstanceRequest>
        Model::GetOnPremisesInstanceOutcomeCallable GetOnPremisesInstanceCallable(const GetOnPremisesInstanceRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::GetOnPremisesInstance, request);
        }
 
        template<typename GetOnPremisesInstanceRequestT = Model::GetOnPremisesInstanceRequest>
        void GetOnPremisesInstanceAsync(const GetOnPremisesInstanceRequestT& request, const GetOnPremisesInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::GetOnPremisesInstance, request, handler, context);
        }
 
        virtual Model::ListApplicationRevisionsOutcome ListApplicationRevisions(const Model::ListApplicationRevisionsRequest& request) const;
 
        template<typename ListApplicationRevisionsRequestT = Model::ListApplicationRevisionsRequest>
        Model::ListApplicationRevisionsOutcomeCallable ListApplicationRevisionsCallable(const ListApplicationRevisionsRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::ListApplicationRevisions, request);
        }
 
        template<typename ListApplicationRevisionsRequestT = Model::ListApplicationRevisionsRequest>
        void ListApplicationRevisionsAsync(const ListApplicationRevisionsRequestT& request, const ListApplicationRevisionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::ListApplicationRevisions, request, handler, context);
        }
 
        virtual Model::ListApplicationsOutcome ListApplications(const Model::ListApplicationsRequest& request = {}) const;
 
        template<typename ListApplicationsRequestT = Model::ListApplicationsRequest>
        Model::ListApplicationsOutcomeCallable ListApplicationsCallable(const ListApplicationsRequestT& request = {}) const
        {
            return SubmitCallable(&CodeDeployClient::ListApplications, request);
        }
 
        template<typename ListApplicationsRequestT = Model::ListApplicationsRequest>
        void ListApplicationsAsync(const ListApplicationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListApplicationsRequestT& request = {}) const
        {
            return SubmitAsync(&CodeDeployClient::ListApplications, request, handler, context);
        }
 
        virtual Model::ListDeploymentConfigsOutcome ListDeploymentConfigs(const Model::ListDeploymentConfigsRequest& request = {}) const;
 
        template<typename ListDeploymentConfigsRequestT = Model::ListDeploymentConfigsRequest>
        Model::ListDeploymentConfigsOutcomeCallable ListDeploymentConfigsCallable(const ListDeploymentConfigsRequestT& request = {}) const
        {
            return SubmitCallable(&CodeDeployClient::ListDeploymentConfigs, request);
        }
 
        template<typename ListDeploymentConfigsRequestT = Model::ListDeploymentConfigsRequest>
        void ListDeploymentConfigsAsync(const ListDeploymentConfigsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDeploymentConfigsRequestT& request = {}) const
        {
            return SubmitAsync(&CodeDeployClient::ListDeploymentConfigs, request, handler, context);
        }
 
        virtual Model::ListDeploymentGroupsOutcome ListDeploymentGroups(const Model::ListDeploymentGroupsRequest& request) const;
 
        template<typename ListDeploymentGroupsRequestT = Model::ListDeploymentGroupsRequest>
        Model::ListDeploymentGroupsOutcomeCallable ListDeploymentGroupsCallable(const ListDeploymentGroupsRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::ListDeploymentGroups, request);
        }
 
        template<typename ListDeploymentGroupsRequestT = Model::ListDeploymentGroupsRequest>
        void ListDeploymentGroupsAsync(const ListDeploymentGroupsRequestT& request, const ListDeploymentGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::ListDeploymentGroups, request, handler, context);
        }
 
        virtual Model::ListDeploymentTargetsOutcome ListDeploymentTargets(const Model::ListDeploymentTargetsRequest& request) const;
 
        template<typename ListDeploymentTargetsRequestT = Model::ListDeploymentTargetsRequest>
        Model::ListDeploymentTargetsOutcomeCallable ListDeploymentTargetsCallable(const ListDeploymentTargetsRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::ListDeploymentTargets, request);
        }
 
        template<typename ListDeploymentTargetsRequestT = Model::ListDeploymentTargetsRequest>
        void ListDeploymentTargetsAsync(const ListDeploymentTargetsRequestT& request, const ListDeploymentTargetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::ListDeploymentTargets, request, handler, context);
        }
 
        virtual Model::ListDeploymentsOutcome ListDeployments(const Model::ListDeploymentsRequest& request = {}) const;
 
        template<typename ListDeploymentsRequestT = Model::ListDeploymentsRequest>
        Model::ListDeploymentsOutcomeCallable ListDeploymentsCallable(const ListDeploymentsRequestT& request = {}) const
        {
            return SubmitCallable(&CodeDeployClient::ListDeployments, request);
        }
 
        template<typename ListDeploymentsRequestT = Model::ListDeploymentsRequest>
        void ListDeploymentsAsync(const ListDeploymentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDeploymentsRequestT& request = {}) const
        {
            return SubmitAsync(&CodeDeployClient::ListDeployments, request, handler, context);
        }
 
        virtual Model::ListGitHubAccountTokenNamesOutcome ListGitHubAccountTokenNames(const Model::ListGitHubAccountTokenNamesRequest& request = {}) const;
 
        template<typename ListGitHubAccountTokenNamesRequestT = Model::ListGitHubAccountTokenNamesRequest>
        Model::ListGitHubAccountTokenNamesOutcomeCallable ListGitHubAccountTokenNamesCallable(const ListGitHubAccountTokenNamesRequestT& request = {}) const
        {
            return SubmitCallable(&CodeDeployClient::ListGitHubAccountTokenNames, request);
        }
 
        template<typename ListGitHubAccountTokenNamesRequestT = Model::ListGitHubAccountTokenNamesRequest>
        void ListGitHubAccountTokenNamesAsync(const ListGitHubAccountTokenNamesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListGitHubAccountTokenNamesRequestT& request = {}) const
        {
            return SubmitAsync(&CodeDeployClient::ListGitHubAccountTokenNames, request, handler, context);
        }
 
        virtual Model::ListOnPremisesInstancesOutcome ListOnPremisesInstances(const Model::ListOnPremisesInstancesRequest& request = {}) const;
 
        template<typename ListOnPremisesInstancesRequestT = Model::ListOnPremisesInstancesRequest>
        Model::ListOnPremisesInstancesOutcomeCallable ListOnPremisesInstancesCallable(const ListOnPremisesInstancesRequestT& request = {}) const
        {
            return SubmitCallable(&CodeDeployClient::ListOnPremisesInstances, request);
        }
 
        template<typename ListOnPremisesInstancesRequestT = Model::ListOnPremisesInstancesRequest>
        void ListOnPremisesInstancesAsync(const ListOnPremisesInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListOnPremisesInstancesRequestT& request = {}) const
        {
            return SubmitAsync(&CodeDeployClient::ListOnPremisesInstances, 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(&CodeDeployClient::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(&CodeDeployClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PutLifecycleEventHookExecutionStatusOutcome PutLifecycleEventHookExecutionStatus(const Model::PutLifecycleEventHookExecutionStatusRequest& request = {}) const;
 
        template<typename PutLifecycleEventHookExecutionStatusRequestT = Model::PutLifecycleEventHookExecutionStatusRequest>
        Model::PutLifecycleEventHookExecutionStatusOutcomeCallable PutLifecycleEventHookExecutionStatusCallable(const PutLifecycleEventHookExecutionStatusRequestT& request = {}) const
        {
            return SubmitCallable(&CodeDeployClient::PutLifecycleEventHookExecutionStatus, request);
        }
 
        template<typename PutLifecycleEventHookExecutionStatusRequestT = Model::PutLifecycleEventHookExecutionStatusRequest>
        void PutLifecycleEventHookExecutionStatusAsync(const PutLifecycleEventHookExecutionStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const PutLifecycleEventHookExecutionStatusRequestT& request = {}) const
        {
            return SubmitAsync(&CodeDeployClient::PutLifecycleEventHookExecutionStatus, request, handler, context);
        }
 
        virtual Model::RegisterApplicationRevisionOutcome RegisterApplicationRevision(const Model::RegisterApplicationRevisionRequest& request) const;
 
        template<typename RegisterApplicationRevisionRequestT = Model::RegisterApplicationRevisionRequest>
        Model::RegisterApplicationRevisionOutcomeCallable RegisterApplicationRevisionCallable(const RegisterApplicationRevisionRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::RegisterApplicationRevision, request);
        }
 
        template<typename RegisterApplicationRevisionRequestT = Model::RegisterApplicationRevisionRequest>
        void RegisterApplicationRevisionAsync(const RegisterApplicationRevisionRequestT& request, const RegisterApplicationRevisionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::RegisterApplicationRevision, request, handler, context);
        }
 
        virtual Model::RegisterOnPremisesInstanceOutcome RegisterOnPremisesInstance(const Model::RegisterOnPremisesInstanceRequest& request) const;
 
        template<typename RegisterOnPremisesInstanceRequestT = Model::RegisterOnPremisesInstanceRequest>
        Model::RegisterOnPremisesInstanceOutcomeCallable RegisterOnPremisesInstanceCallable(const RegisterOnPremisesInstanceRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::RegisterOnPremisesInstance, request);
        }
 
        template<typename RegisterOnPremisesInstanceRequestT = Model::RegisterOnPremisesInstanceRequest>
        void RegisterOnPremisesInstanceAsync(const RegisterOnPremisesInstanceRequestT& request, const RegisterOnPremisesInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::RegisterOnPremisesInstance, request, handler, context);
        }
 
        virtual Model::RemoveTagsFromOnPremisesInstancesOutcome RemoveTagsFromOnPremisesInstances(const Model::RemoveTagsFromOnPremisesInstancesRequest& request) const;
 
        template<typename RemoveTagsFromOnPremisesInstancesRequestT = Model::RemoveTagsFromOnPremisesInstancesRequest>
        Model::RemoveTagsFromOnPremisesInstancesOutcomeCallable RemoveTagsFromOnPremisesInstancesCallable(const RemoveTagsFromOnPremisesInstancesRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::RemoveTagsFromOnPremisesInstances, request);
        }
 
        template<typename RemoveTagsFromOnPremisesInstancesRequestT = Model::RemoveTagsFromOnPremisesInstancesRequest>
        void RemoveTagsFromOnPremisesInstancesAsync(const RemoveTagsFromOnPremisesInstancesRequestT& request, const RemoveTagsFromOnPremisesInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::RemoveTagsFromOnPremisesInstances, request, handler, context);
        }
 
        virtual Model::StopDeploymentOutcome StopDeployment(const Model::StopDeploymentRequest& request) const;
 
        template<typename StopDeploymentRequestT = Model::StopDeploymentRequest>
        Model::StopDeploymentOutcomeCallable StopDeploymentCallable(const StopDeploymentRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::StopDeployment, request);
        }
 
        template<typename StopDeploymentRequestT = Model::StopDeploymentRequest>
        void StopDeploymentAsync(const StopDeploymentRequestT& request, const StopDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::StopDeployment, 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(&CodeDeployClient::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(&CodeDeployClient::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(&CodeDeployClient::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(&CodeDeployClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateApplicationOutcome UpdateApplication(const Model::UpdateApplicationRequest& request = {}) const;
 
        template<typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
        Model::UpdateApplicationOutcomeCallable UpdateApplicationCallable(const UpdateApplicationRequestT& request = {}) const
        {
            return SubmitCallable(&CodeDeployClient::UpdateApplication, request);
        }
 
        template<typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
        void UpdateApplicationAsync(const UpdateApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateApplicationRequestT& request = {}) const
        {
            return SubmitAsync(&CodeDeployClient::UpdateApplication, request, handler, context);
        }
 
        virtual Model::UpdateDeploymentGroupOutcome UpdateDeploymentGroup(const Model::UpdateDeploymentGroupRequest& request) const;
 
        template<typename UpdateDeploymentGroupRequestT = Model::UpdateDeploymentGroupRequest>
        Model::UpdateDeploymentGroupOutcomeCallable UpdateDeploymentGroupCallable(const UpdateDeploymentGroupRequestT& request) const
        {
            return SubmitCallable(&CodeDeployClient::UpdateDeploymentGroup, request);
        }
 
        template<typename UpdateDeploymentGroupRequestT = Model::UpdateDeploymentGroupRequest>
        void UpdateDeploymentGroupAsync(const UpdateDeploymentGroupRequestT& request, const UpdateDeploymentGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeDeployClient::UpdateDeploymentGroup, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<CodeDeployEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<CodeDeployClient>;
      void init(const CodeDeployClientConfiguration& clientConfiguration);
 
      CodeDeployClientConfiguration m_clientConfiguration;
      std::shared_ptr<CodeDeployEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace CodeDeploy
} // namespace Aws