CodeDeployClient.h

 
#pragma once
#include <aws/codedeploy/CodeDeployServiceClientModel.h>
#include <aws/codedeploy/CodeDeploy_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 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