DevOpsAgentClient.h

 
#pragma once
#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>
#include <aws/devops-agent/DevOpsAgentPaginationBase.h>
#include <aws/devops-agent/DevOpsAgentServiceClientModel.h>
#include <aws/devops-agent/DevOpsAgentWaiter.h>
#include <aws/devops-agent/DevOpsAgent_EXPORTS.h>
 
namespace Aws {
namespace DevOpsAgent {
class AWS_DEVOPSAGENT_API DevOpsAgentClient : public Aws::Client::AWSJsonClient,
                                              public Aws::Client::ClientWithAsyncTemplateMethods<DevOpsAgentClient>,
                                              public DevOpsAgentPaginationBase<DevOpsAgentClient>,
                                              public DevOpsAgentWaiter<DevOpsAgentClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef DevOpsAgentClientConfiguration ClientConfigurationType;
  typedef DevOpsAgentEndpointProvider EndpointProviderType;
 
  DevOpsAgentClient(
      const Aws::DevOpsAgent::DevOpsAgentClientConfiguration& clientConfiguration = Aws::DevOpsAgent::DevOpsAgentClientConfiguration(),
      std::shared_ptr<DevOpsAgentEndpointProviderBase> endpointProvider = nullptr);
 
  DevOpsAgentClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<DevOpsAgentEndpointProviderBase> endpointProvider = nullptr,
      const Aws::DevOpsAgent::DevOpsAgentClientConfiguration& clientConfiguration = Aws::DevOpsAgent::DevOpsAgentClientConfiguration());
 
  DevOpsAgentClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<DevOpsAgentEndpointProviderBase> endpointProvider = nullptr,
      const Aws::DevOpsAgent::DevOpsAgentClientConfiguration& clientConfiguration = Aws::DevOpsAgent::DevOpsAgentClientConfiguration());
 
  /* Legacy constructors due deprecation */
  DevOpsAgentClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  DevOpsAgentClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  DevOpsAgentClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                    const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~DevOpsAgentClient();
 
  virtual Model::AssociateServiceOutcome AssociateService(const Model::AssociateServiceRequest& request) const;
 
  template <typename AssociateServiceRequestT = Model::AssociateServiceRequest>
  Model::AssociateServiceOutcomeCallable AssociateServiceCallable(const AssociateServiceRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::AssociateService, request);
  }
 
  template <typename AssociateServiceRequestT = Model::AssociateServiceRequest>
  void AssociateServiceAsync(const AssociateServiceRequestT& request, const AssociateServiceResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::AssociateService, request, handler, context);
  }
 
  virtual Model::CreateAgentSpaceOutcome CreateAgentSpace(const Model::CreateAgentSpaceRequest& request) const;
 
  template <typename CreateAgentSpaceRequestT = Model::CreateAgentSpaceRequest>
  Model::CreateAgentSpaceOutcomeCallable CreateAgentSpaceCallable(const CreateAgentSpaceRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::CreateAgentSpace, request);
  }
 
  template <typename CreateAgentSpaceRequestT = Model::CreateAgentSpaceRequest>
  void CreateAgentSpaceAsync(const CreateAgentSpaceRequestT& request, const CreateAgentSpaceResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::CreateAgentSpace, request, handler, context);
  }
 
  virtual Model::CreateAssetOutcome CreateAsset(const Model::CreateAssetRequest& request) const;
 
  template <typename CreateAssetRequestT = Model::CreateAssetRequest>
  Model::CreateAssetOutcomeCallable CreateAssetCallable(const CreateAssetRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::CreateAsset, request);
  }
 
  template <typename CreateAssetRequestT = Model::CreateAssetRequest>
  void CreateAssetAsync(const CreateAssetRequestT& request, const CreateAssetResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::CreateAsset, request, handler, context);
  }
 
  virtual Model::CreateAssetFileOutcome CreateAssetFile(const Model::CreateAssetFileRequest& request) const;
 
  template <typename CreateAssetFileRequestT = Model::CreateAssetFileRequest>
  Model::CreateAssetFileOutcomeCallable CreateAssetFileCallable(const CreateAssetFileRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::CreateAssetFile, request);
  }
 
  template <typename CreateAssetFileRequestT = Model::CreateAssetFileRequest>
  void CreateAssetFileAsync(const CreateAssetFileRequestT& request, const CreateAssetFileResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::CreateAssetFile, request, handler, context);
  }
 
  virtual Model::CreateBacklogTaskOutcome CreateBacklogTask(const Model::CreateBacklogTaskRequest& request) const;
 
  template <typename CreateBacklogTaskRequestT = Model::CreateBacklogTaskRequest>
  Model::CreateBacklogTaskOutcomeCallable CreateBacklogTaskCallable(const CreateBacklogTaskRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::CreateBacklogTask, request);
  }
 
  template <typename CreateBacklogTaskRequestT = Model::CreateBacklogTaskRequest>
  void CreateBacklogTaskAsync(const CreateBacklogTaskRequestT& request, const CreateBacklogTaskResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::CreateBacklogTask, request, handler, context);
  }
 
  virtual Model::CreateChatOutcome CreateChat(const Model::CreateChatRequest& request) const;
 
  template <typename CreateChatRequestT = Model::CreateChatRequest>
  Model::CreateChatOutcomeCallable CreateChatCallable(const CreateChatRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::CreateChat, request);
  }
 
  template <typename CreateChatRequestT = Model::CreateChatRequest>
  void CreateChatAsync(const CreateChatRequestT& request, const CreateChatResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::CreateChat, request, handler, context);
  }
 
  virtual Model::CreatePrivateConnectionOutcome CreatePrivateConnection(const Model::CreatePrivateConnectionRequest& request) const;
 
  template <typename CreatePrivateConnectionRequestT = Model::CreatePrivateConnectionRequest>
  Model::CreatePrivateConnectionOutcomeCallable CreatePrivateConnectionCallable(const CreatePrivateConnectionRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::CreatePrivateConnection, request);
  }
 
  template <typename CreatePrivateConnectionRequestT = Model::CreatePrivateConnectionRequest>
  void CreatePrivateConnectionAsync(const CreatePrivateConnectionRequestT& request,
                                    const CreatePrivateConnectionResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::CreatePrivateConnection, request, handler, context);
  }
 
  virtual Model::CreateTriggerOutcome CreateTrigger(const Model::CreateTriggerRequest& request) const;
 
  template <typename CreateTriggerRequestT = Model::CreateTriggerRequest>
  Model::CreateTriggerOutcomeCallable CreateTriggerCallable(const CreateTriggerRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::CreateTrigger, request);
  }
 
  template <typename CreateTriggerRequestT = Model::CreateTriggerRequest>
  void CreateTriggerAsync(const CreateTriggerRequestT& request, const CreateTriggerResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::CreateTrigger, request, handler, context);
  }
 
  virtual Model::DeleteAgentSpaceOutcome DeleteAgentSpace(const Model::DeleteAgentSpaceRequest& request) const;
 
  template <typename DeleteAgentSpaceRequestT = Model::DeleteAgentSpaceRequest>
  Model::DeleteAgentSpaceOutcomeCallable DeleteAgentSpaceCallable(const DeleteAgentSpaceRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::DeleteAgentSpace, request);
  }
 
  template <typename DeleteAgentSpaceRequestT = Model::DeleteAgentSpaceRequest>
  void DeleteAgentSpaceAsync(const DeleteAgentSpaceRequestT& request, const DeleteAgentSpaceResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::DeleteAgentSpace, request, handler, context);
  }
 
  virtual Model::DeleteAssetOutcome DeleteAsset(const Model::DeleteAssetRequest& request) const;
 
  template <typename DeleteAssetRequestT = Model::DeleteAssetRequest>
  Model::DeleteAssetOutcomeCallable DeleteAssetCallable(const DeleteAssetRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::DeleteAsset, request);
  }
 
  template <typename DeleteAssetRequestT = Model::DeleteAssetRequest>
  void DeleteAssetAsync(const DeleteAssetRequestT& request, const DeleteAssetResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::DeleteAsset, request, handler, context);
  }
 
  virtual Model::DeleteAssetFileOutcome DeleteAssetFile(const Model::DeleteAssetFileRequest& request) const;
 
  template <typename DeleteAssetFileRequestT = Model::DeleteAssetFileRequest>
  Model::DeleteAssetFileOutcomeCallable DeleteAssetFileCallable(const DeleteAssetFileRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::DeleteAssetFile, request);
  }
 
  template <typename DeleteAssetFileRequestT = Model::DeleteAssetFileRequest>
  void DeleteAssetFileAsync(const DeleteAssetFileRequestT& request, const DeleteAssetFileResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::DeleteAssetFile, request, handler, context);
  }
 
  virtual Model::DeletePrivateConnectionOutcome DeletePrivateConnection(const Model::DeletePrivateConnectionRequest& request) const;
 
  template <typename DeletePrivateConnectionRequestT = Model::DeletePrivateConnectionRequest>
  Model::DeletePrivateConnectionOutcomeCallable DeletePrivateConnectionCallable(const DeletePrivateConnectionRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::DeletePrivateConnection, request);
  }
 
  template <typename DeletePrivateConnectionRequestT = Model::DeletePrivateConnectionRequest>
  void DeletePrivateConnectionAsync(const DeletePrivateConnectionRequestT& request,
                                    const DeletePrivateConnectionResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::DeletePrivateConnection, request, handler, context);
  }
 
  virtual Model::DeleteTriggerOutcome DeleteTrigger(const Model::DeleteTriggerRequest& request) const;
 
  template <typename DeleteTriggerRequestT = Model::DeleteTriggerRequest>
  Model::DeleteTriggerOutcomeCallable DeleteTriggerCallable(const DeleteTriggerRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::DeleteTrigger, request);
  }
 
  template <typename DeleteTriggerRequestT = Model::DeleteTriggerRequest>
  void DeleteTriggerAsync(const DeleteTriggerRequestT& request, const DeleteTriggerResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::DeleteTrigger, request, handler, context);
  }
 
  virtual Model::DeregisterServiceOutcome DeregisterService(const Model::DeregisterServiceRequest& request) const;
 
  template <typename DeregisterServiceRequestT = Model::DeregisterServiceRequest>
  Model::DeregisterServiceOutcomeCallable DeregisterServiceCallable(const DeregisterServiceRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::DeregisterService, request);
  }
 
  template <typename DeregisterServiceRequestT = Model::DeregisterServiceRequest>
  void DeregisterServiceAsync(const DeregisterServiceRequestT& request, const DeregisterServiceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::DeregisterService, request, handler, context);
  }
 
  virtual Model::DescribePrivateConnectionOutcome DescribePrivateConnection(const Model::DescribePrivateConnectionRequest& request) const;
 
  template <typename DescribePrivateConnectionRequestT = Model::DescribePrivateConnectionRequest>
  Model::DescribePrivateConnectionOutcomeCallable DescribePrivateConnectionCallable(
      const DescribePrivateConnectionRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::DescribePrivateConnection, request);
  }
 
  template <typename DescribePrivateConnectionRequestT = Model::DescribePrivateConnectionRequest>
  void DescribePrivateConnectionAsync(const DescribePrivateConnectionRequestT& request,
                                      const DescribePrivateConnectionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::DescribePrivateConnection, request, handler, context);
  }
 
  virtual Model::DisableOperatorAppOutcome DisableOperatorApp(const Model::DisableOperatorAppRequest& request) const;
 
  template <typename DisableOperatorAppRequestT = Model::DisableOperatorAppRequest>
  Model::DisableOperatorAppOutcomeCallable DisableOperatorAppCallable(const DisableOperatorAppRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::DisableOperatorApp, request);
  }
 
  template <typename DisableOperatorAppRequestT = Model::DisableOperatorAppRequest>
  void DisableOperatorAppAsync(const DisableOperatorAppRequestT& request, const DisableOperatorAppResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::DisableOperatorApp, request, handler, context);
  }
 
  virtual Model::DisassociateServiceOutcome DisassociateService(const Model::DisassociateServiceRequest& request) const;
 
  template <typename DisassociateServiceRequestT = Model::DisassociateServiceRequest>
  Model::DisassociateServiceOutcomeCallable DisassociateServiceCallable(const DisassociateServiceRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::DisassociateService, request);
  }
 
  template <typename DisassociateServiceRequestT = Model::DisassociateServiceRequest>
  void DisassociateServiceAsync(const DisassociateServiceRequestT& request, const DisassociateServiceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::DisassociateService, request, handler, context);
  }
 
  virtual Model::EnableOperatorAppOutcome EnableOperatorApp(const Model::EnableOperatorAppRequest& request) const;
 
  template <typename EnableOperatorAppRequestT = Model::EnableOperatorAppRequest>
  Model::EnableOperatorAppOutcomeCallable EnableOperatorAppCallable(const EnableOperatorAppRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::EnableOperatorApp, request);
  }
 
  template <typename EnableOperatorAppRequestT = Model::EnableOperatorAppRequest>
  void EnableOperatorAppAsync(const EnableOperatorAppRequestT& request, const EnableOperatorAppResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::EnableOperatorApp, request, handler, context);
  }
 
  virtual Model::GetAccountUsageOutcome GetAccountUsage(const Model::GetAccountUsageRequest& request = {}) const;
 
  template <typename GetAccountUsageRequestT = Model::GetAccountUsageRequest>
  Model::GetAccountUsageOutcomeCallable GetAccountUsageCallable(const GetAccountUsageRequestT& request = {}) const {
    return SubmitCallable(&DevOpsAgentClient::GetAccountUsage, request);
  }
 
  template <typename GetAccountUsageRequestT = Model::GetAccountUsageRequest>
  void GetAccountUsageAsync(const GetAccountUsageResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const GetAccountUsageRequestT& request = {}) const {
    return SubmitAsync(&DevOpsAgentClient::GetAccountUsage, request, handler, context);
  }
 
  virtual Model::GetAgentSpaceOutcome GetAgentSpace(const Model::GetAgentSpaceRequest& request) const;
 
  template <typename GetAgentSpaceRequestT = Model::GetAgentSpaceRequest>
  Model::GetAgentSpaceOutcomeCallable GetAgentSpaceCallable(const GetAgentSpaceRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::GetAgentSpace, request);
  }
 
  template <typename GetAgentSpaceRequestT = Model::GetAgentSpaceRequest>
  void GetAgentSpaceAsync(const GetAgentSpaceRequestT& request, const GetAgentSpaceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::GetAgentSpace, request, handler, context);
  }
 
  virtual Model::GetAssetOutcome GetAsset(const Model::GetAssetRequest& request) const;
 
  template <typename GetAssetRequestT = Model::GetAssetRequest>
  Model::GetAssetOutcomeCallable GetAssetCallable(const GetAssetRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::GetAsset, request);
  }
 
  template <typename GetAssetRequestT = Model::GetAssetRequest>
  void GetAssetAsync(const GetAssetRequestT& request, const GetAssetResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::GetAsset, request, handler, context);
  }
 
  virtual Model::GetAssetContentOutcome GetAssetContent(const Model::GetAssetContentRequest& request) const;
 
  template <typename GetAssetContentRequestT = Model::GetAssetContentRequest>
  Model::GetAssetContentOutcomeCallable GetAssetContentCallable(const GetAssetContentRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::GetAssetContent, request);
  }
 
  template <typename GetAssetContentRequestT = Model::GetAssetContentRequest>
  void GetAssetContentAsync(const GetAssetContentRequestT& request, const GetAssetContentResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::GetAssetContent, request, handler, context);
  }
 
  virtual Model::GetAssetFileOutcome GetAssetFile(const Model::GetAssetFileRequest& request) const;
 
  template <typename GetAssetFileRequestT = Model::GetAssetFileRequest>
  Model::GetAssetFileOutcomeCallable GetAssetFileCallable(const GetAssetFileRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::GetAssetFile, request);
  }
 
  template <typename GetAssetFileRequestT = Model::GetAssetFileRequest>
  void GetAssetFileAsync(const GetAssetFileRequestT& request, const GetAssetFileResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::GetAssetFile, request, handler, context);
  }
 
  virtual Model::GetAssociationOutcome GetAssociation(const Model::GetAssociationRequest& request) const;
 
  template <typename GetAssociationRequestT = Model::GetAssociationRequest>
  Model::GetAssociationOutcomeCallable GetAssociationCallable(const GetAssociationRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::GetAssociation, request);
  }
 
  template <typename GetAssociationRequestT = Model::GetAssociationRequest>
  void GetAssociationAsync(const GetAssociationRequestT& request, const GetAssociationResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::GetAssociation, request, handler, context);
  }
 
  virtual Model::GetBacklogTaskOutcome GetBacklogTask(const Model::GetBacklogTaskRequest& request) const;
 
  template <typename GetBacklogTaskRequestT = Model::GetBacklogTaskRequest>
  Model::GetBacklogTaskOutcomeCallable GetBacklogTaskCallable(const GetBacklogTaskRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::GetBacklogTask, request);
  }
 
  template <typename GetBacklogTaskRequestT = Model::GetBacklogTaskRequest>
  void GetBacklogTaskAsync(const GetBacklogTaskRequestT& request, const GetBacklogTaskResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::GetBacklogTask, request, handler, context);
  }
 
  virtual Model::GetOperatorAppOutcome GetOperatorApp(const Model::GetOperatorAppRequest& request) const;
 
  template <typename GetOperatorAppRequestT = Model::GetOperatorAppRequest>
  Model::GetOperatorAppOutcomeCallable GetOperatorAppCallable(const GetOperatorAppRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::GetOperatorApp, request);
  }
 
  template <typename GetOperatorAppRequestT = Model::GetOperatorAppRequest>
  void GetOperatorAppAsync(const GetOperatorAppRequestT& request, const GetOperatorAppResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::GetOperatorApp, request, handler, context);
  }
 
  virtual Model::GetRecommendationOutcome GetRecommendation(const Model::GetRecommendationRequest& request) const;
 
  template <typename GetRecommendationRequestT = Model::GetRecommendationRequest>
  Model::GetRecommendationOutcomeCallable GetRecommendationCallable(const GetRecommendationRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::GetRecommendation, request);
  }
 
  template <typename GetRecommendationRequestT = Model::GetRecommendationRequest>
  void GetRecommendationAsync(const GetRecommendationRequestT& request, const GetRecommendationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::GetRecommendation, request, handler, context);
  }
 
  virtual Model::GetServiceOutcome GetService(const Model::GetServiceRequest& request) const;
 
  template <typename GetServiceRequestT = Model::GetServiceRequest>
  Model::GetServiceOutcomeCallable GetServiceCallable(const GetServiceRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::GetService, request);
  }
 
  template <typename GetServiceRequestT = Model::GetServiceRequest>
  void GetServiceAsync(const GetServiceRequestT& request, const GetServiceResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::GetService, request, handler, context);
  }
 
  virtual Model::GetTriggerOutcome GetTrigger(const Model::GetTriggerRequest& request) const;
 
  template <typename GetTriggerRequestT = Model::GetTriggerRequest>
  Model::GetTriggerOutcomeCallable GetTriggerCallable(const GetTriggerRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::GetTrigger, request);
  }
 
  template <typename GetTriggerRequestT = Model::GetTriggerRequest>
  void GetTriggerAsync(const GetTriggerRequestT& request, const GetTriggerResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::GetTrigger, request, handler, context);
  }
 
  virtual Model::ListAgentSpacesOutcome ListAgentSpaces(const Model::ListAgentSpacesRequest& request = {}) const;
 
  template <typename ListAgentSpacesRequestT = Model::ListAgentSpacesRequest>
  Model::ListAgentSpacesOutcomeCallable ListAgentSpacesCallable(const ListAgentSpacesRequestT& request = {}) const {
    return SubmitCallable(&DevOpsAgentClient::ListAgentSpaces, request);
  }
 
  template <typename ListAgentSpacesRequestT = Model::ListAgentSpacesRequest>
  void ListAgentSpacesAsync(const ListAgentSpacesResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const ListAgentSpacesRequestT& request = {}) const {
    return SubmitAsync(&DevOpsAgentClient::ListAgentSpaces, request, handler, context);
  }
 
  virtual Model::ListAssetFilesOutcome ListAssetFiles(const Model::ListAssetFilesRequest& request) const;
 
  template <typename ListAssetFilesRequestT = Model::ListAssetFilesRequest>
  Model::ListAssetFilesOutcomeCallable ListAssetFilesCallable(const ListAssetFilesRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::ListAssetFiles, request);
  }
 
  template <typename ListAssetFilesRequestT = Model::ListAssetFilesRequest>
  void ListAssetFilesAsync(const ListAssetFilesRequestT& request, const ListAssetFilesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::ListAssetFiles, request, handler, context);
  }
 
  virtual Model::ListAssetTypesOutcome ListAssetTypes(const Model::ListAssetTypesRequest& request = {}) const;
 
  template <typename ListAssetTypesRequestT = Model::ListAssetTypesRequest>
  Model::ListAssetTypesOutcomeCallable ListAssetTypesCallable(const ListAssetTypesRequestT& request = {}) const {
    return SubmitCallable(&DevOpsAgentClient::ListAssetTypes, request);
  }
 
  template <typename ListAssetTypesRequestT = Model::ListAssetTypesRequest>
  void ListAssetTypesAsync(const ListAssetTypesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListAssetTypesRequestT& request = {}) const {
    return SubmitAsync(&DevOpsAgentClient::ListAssetTypes, request, handler, context);
  }
 
  virtual Model::ListAssetVersionsOutcome ListAssetVersions(const Model::ListAssetVersionsRequest& request) const;
 
  template <typename ListAssetVersionsRequestT = Model::ListAssetVersionsRequest>
  Model::ListAssetVersionsOutcomeCallable ListAssetVersionsCallable(const ListAssetVersionsRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::ListAssetVersions, request);
  }
 
  template <typename ListAssetVersionsRequestT = Model::ListAssetVersionsRequest>
  void ListAssetVersionsAsync(const ListAssetVersionsRequestT& request, const ListAssetVersionsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::ListAssetVersions, request, handler, context);
  }
 
  virtual Model::ListAssetsOutcome ListAssets(const Model::ListAssetsRequest& request) const;
 
  template <typename ListAssetsRequestT = Model::ListAssetsRequest>
  Model::ListAssetsOutcomeCallable ListAssetsCallable(const ListAssetsRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::ListAssets, request);
  }
 
  template <typename ListAssetsRequestT = Model::ListAssetsRequest>
  void ListAssetsAsync(const ListAssetsRequestT& request, const ListAssetsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::ListAssets, request, handler, context);
  }
 
  virtual Model::ListAssociationsOutcome ListAssociations(const Model::ListAssociationsRequest& request) const;
 
  template <typename ListAssociationsRequestT = Model::ListAssociationsRequest>
  Model::ListAssociationsOutcomeCallable ListAssociationsCallable(const ListAssociationsRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::ListAssociations, request);
  }
 
  template <typename ListAssociationsRequestT = Model::ListAssociationsRequest>
  void ListAssociationsAsync(const ListAssociationsRequestT& request, const ListAssociationsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::ListAssociations, request, handler, context);
  }
 
  virtual Model::ListBacklogTasksOutcome ListBacklogTasks(const Model::ListBacklogTasksRequest& request) const;
 
  template <typename ListBacklogTasksRequestT = Model::ListBacklogTasksRequest>
  Model::ListBacklogTasksOutcomeCallable ListBacklogTasksCallable(const ListBacklogTasksRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::ListBacklogTasks, request);
  }
 
  template <typename ListBacklogTasksRequestT = Model::ListBacklogTasksRequest>
  void ListBacklogTasksAsync(const ListBacklogTasksRequestT& request, const ListBacklogTasksResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::ListBacklogTasks, request, handler, context);
  }
 
  virtual Model::ListChatsOutcome ListChats(const Model::ListChatsRequest& request) const;
 
  template <typename ListChatsRequestT = Model::ListChatsRequest>
  Model::ListChatsOutcomeCallable ListChatsCallable(const ListChatsRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::ListChats, request);
  }
 
  template <typename ListChatsRequestT = Model::ListChatsRequest>
  void ListChatsAsync(const ListChatsRequestT& request, const ListChatsResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::ListChats, request, handler, context);
  }
 
  virtual Model::ListExecutionsOutcome ListExecutions(const Model::ListExecutionsRequest& request) const;
 
  template <typename ListExecutionsRequestT = Model::ListExecutionsRequest>
  Model::ListExecutionsOutcomeCallable ListExecutionsCallable(const ListExecutionsRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::ListExecutions, request);
  }
 
  template <typename ListExecutionsRequestT = Model::ListExecutionsRequest>
  void ListExecutionsAsync(const ListExecutionsRequestT& request, const ListExecutionsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::ListExecutions, request, handler, context);
  }
 
  virtual Model::ListGoalsOutcome ListGoals(const Model::ListGoalsRequest& request) const;
 
  template <typename ListGoalsRequestT = Model::ListGoalsRequest>
  Model::ListGoalsOutcomeCallable ListGoalsCallable(const ListGoalsRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::ListGoals, request);
  }
 
  template <typename ListGoalsRequestT = Model::ListGoalsRequest>
  void ListGoalsAsync(const ListGoalsRequestT& request, const ListGoalsResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::ListGoals, request, handler, context);
  }
 
  virtual Model::ListJournalRecordsOutcome ListJournalRecords(const Model::ListJournalRecordsRequest& request) const;
 
  template <typename ListJournalRecordsRequestT = Model::ListJournalRecordsRequest>
  Model::ListJournalRecordsOutcomeCallable ListJournalRecordsCallable(const ListJournalRecordsRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::ListJournalRecords, request);
  }
 
  template <typename ListJournalRecordsRequestT = Model::ListJournalRecordsRequest>
  void ListJournalRecordsAsync(const ListJournalRecordsRequestT& request, const ListJournalRecordsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::ListJournalRecords, request, handler, context);
  }
 
  virtual Model::ListPendingMessagesOutcome ListPendingMessages(const Model::ListPendingMessagesRequest& request) const;
 
  template <typename ListPendingMessagesRequestT = Model::ListPendingMessagesRequest>
  Model::ListPendingMessagesOutcomeCallable ListPendingMessagesCallable(const ListPendingMessagesRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::ListPendingMessages, request);
  }
 
  template <typename ListPendingMessagesRequestT = Model::ListPendingMessagesRequest>
  void ListPendingMessagesAsync(const ListPendingMessagesRequestT& request, const ListPendingMessagesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::ListPendingMessages, request, handler, context);
  }
 
  virtual Model::ListPrivateConnectionsOutcome ListPrivateConnections(const Model::ListPrivateConnectionsRequest& request = {}) const;
 
  template <typename ListPrivateConnectionsRequestT = Model::ListPrivateConnectionsRequest>
  Model::ListPrivateConnectionsOutcomeCallable ListPrivateConnectionsCallable(const ListPrivateConnectionsRequestT& request = {}) const {
    return SubmitCallable(&DevOpsAgentClient::ListPrivateConnections, request);
  }
 
  template <typename ListPrivateConnectionsRequestT = Model::ListPrivateConnectionsRequest>
  void ListPrivateConnectionsAsync(const ListPrivateConnectionsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListPrivateConnectionsRequestT& request = {}) const {
    return SubmitAsync(&DevOpsAgentClient::ListPrivateConnections, request, handler, context);
  }
 
  virtual Model::ListRecommendationsOutcome ListRecommendations(const Model::ListRecommendationsRequest& request) const;
 
  template <typename ListRecommendationsRequestT = Model::ListRecommendationsRequest>
  Model::ListRecommendationsOutcomeCallable ListRecommendationsCallable(const ListRecommendationsRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::ListRecommendations, request);
  }
 
  template <typename ListRecommendationsRequestT = Model::ListRecommendationsRequest>
  void ListRecommendationsAsync(const ListRecommendationsRequestT& request, const ListRecommendationsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::ListRecommendations, request, handler, context);
  }
 
  virtual Model::ListServicesOutcome ListServices(const Model::ListServicesRequest& request = {}) const;
 
  template <typename ListServicesRequestT = Model::ListServicesRequest>
  Model::ListServicesOutcomeCallable ListServicesCallable(const ListServicesRequestT& request = {}) const {
    return SubmitCallable(&DevOpsAgentClient::ListServices, request);
  }
 
  template <typename ListServicesRequestT = Model::ListServicesRequest>
  void ListServicesAsync(const ListServicesResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListServicesRequestT& request = {}) const {
    return SubmitAsync(&DevOpsAgentClient::ListServices, 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(&DevOpsAgentClient::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(&DevOpsAgentClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTriggersOutcome ListTriggers(const Model::ListTriggersRequest& request) const;
 
  template <typename ListTriggersRequestT = Model::ListTriggersRequest>
  Model::ListTriggersOutcomeCallable ListTriggersCallable(const ListTriggersRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::ListTriggers, request);
  }
 
  template <typename ListTriggersRequestT = Model::ListTriggersRequest>
  void ListTriggersAsync(const ListTriggersRequestT& request, const ListTriggersResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::ListTriggers, request, handler, context);
  }
 
  virtual Model::ListWebhooksOutcome ListWebhooks(const Model::ListWebhooksRequest& request) const;
 
  template <typename ListWebhooksRequestT = Model::ListWebhooksRequest>
  Model::ListWebhooksOutcomeCallable ListWebhooksCallable(const ListWebhooksRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::ListWebhooks, request);
  }
 
  template <typename ListWebhooksRequestT = Model::ListWebhooksRequest>
  void ListWebhooksAsync(const ListWebhooksRequestT& request, const ListWebhooksResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::ListWebhooks, request, handler, context);
  }
 
  virtual Model::RegisterServiceOutcome RegisterService(const Model::RegisterServiceRequest& request) const;
 
  template <typename RegisterServiceRequestT = Model::RegisterServiceRequest>
  Model::RegisterServiceOutcomeCallable RegisterServiceCallable(const RegisterServiceRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::RegisterService, request);
  }
 
  template <typename RegisterServiceRequestT = Model::RegisterServiceRequest>
  void RegisterServiceAsync(const RegisterServiceRequestT& request, const RegisterServiceResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::RegisterService, request, handler, context);
  }
 
  virtual Model::SendMessageOutcome SendMessage(Model::SendMessageRequest& request) const;
 
  template <typename SendMessageRequestT = Model::SendMessageRequest>
  Model::SendMessageOutcomeCallable SendMessageCallable(SendMessageRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::SendMessage, request);
  }
 
  template <typename SendMessageRequestT = Model::SendMessageRequest>
  void SendMessageAsync(SendMessageRequestT& request, const SendMessageResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::SendMessage, 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(&DevOpsAgentClient::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(&DevOpsAgentClient::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(&DevOpsAgentClient::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(&DevOpsAgentClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateAgentSpaceOutcome UpdateAgentSpace(const Model::UpdateAgentSpaceRequest& request) const;
 
  template <typename UpdateAgentSpaceRequestT = Model::UpdateAgentSpaceRequest>
  Model::UpdateAgentSpaceOutcomeCallable UpdateAgentSpaceCallable(const UpdateAgentSpaceRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::UpdateAgentSpace, request);
  }
 
  template <typename UpdateAgentSpaceRequestT = Model::UpdateAgentSpaceRequest>
  void UpdateAgentSpaceAsync(const UpdateAgentSpaceRequestT& request, const UpdateAgentSpaceResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::UpdateAgentSpace, request, handler, context);
  }
 
  virtual Model::UpdateAssetOutcome UpdateAsset(const Model::UpdateAssetRequest& request) const;
 
  template <typename UpdateAssetRequestT = Model::UpdateAssetRequest>
  Model::UpdateAssetOutcomeCallable UpdateAssetCallable(const UpdateAssetRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::UpdateAsset, request);
  }
 
  template <typename UpdateAssetRequestT = Model::UpdateAssetRequest>
  void UpdateAssetAsync(const UpdateAssetRequestT& request, const UpdateAssetResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::UpdateAsset, request, handler, context);
  }
 
  virtual Model::UpdateAssetFileOutcome UpdateAssetFile(const Model::UpdateAssetFileRequest& request) const;
 
  template <typename UpdateAssetFileRequestT = Model::UpdateAssetFileRequest>
  Model::UpdateAssetFileOutcomeCallable UpdateAssetFileCallable(const UpdateAssetFileRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::UpdateAssetFile, request);
  }
 
  template <typename UpdateAssetFileRequestT = Model::UpdateAssetFileRequest>
  void UpdateAssetFileAsync(const UpdateAssetFileRequestT& request, const UpdateAssetFileResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::UpdateAssetFile, request, handler, context);
  }
 
  virtual Model::UpdateAssociationOutcome UpdateAssociation(const Model::UpdateAssociationRequest& request) const;
 
  template <typename UpdateAssociationRequestT = Model::UpdateAssociationRequest>
  Model::UpdateAssociationOutcomeCallable UpdateAssociationCallable(const UpdateAssociationRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::UpdateAssociation, request);
  }
 
  template <typename UpdateAssociationRequestT = Model::UpdateAssociationRequest>
  void UpdateAssociationAsync(const UpdateAssociationRequestT& request, const UpdateAssociationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::UpdateAssociation, request, handler, context);
  }
 
  virtual Model::UpdateBacklogTaskOutcome UpdateBacklogTask(const Model::UpdateBacklogTaskRequest& request) const;
 
  template <typename UpdateBacklogTaskRequestT = Model::UpdateBacklogTaskRequest>
  Model::UpdateBacklogTaskOutcomeCallable UpdateBacklogTaskCallable(const UpdateBacklogTaskRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::UpdateBacklogTask, request);
  }
 
  template <typename UpdateBacklogTaskRequestT = Model::UpdateBacklogTaskRequest>
  void UpdateBacklogTaskAsync(const UpdateBacklogTaskRequestT& request, const UpdateBacklogTaskResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::UpdateBacklogTask, request, handler, context);
  }
 
  virtual Model::UpdateGoalOutcome UpdateGoal(const Model::UpdateGoalRequest& request) const;
 
  template <typename UpdateGoalRequestT = Model::UpdateGoalRequest>
  Model::UpdateGoalOutcomeCallable UpdateGoalCallable(const UpdateGoalRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::UpdateGoal, request);
  }
 
  template <typename UpdateGoalRequestT = Model::UpdateGoalRequest>
  void UpdateGoalAsync(const UpdateGoalRequestT& request, const UpdateGoalResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::UpdateGoal, request, handler, context);
  }
 
  virtual Model::UpdateOperatorAppIdpConfigOutcome UpdateOperatorAppIdpConfig(
      const Model::UpdateOperatorAppIdpConfigRequest& request) const;
 
  template <typename UpdateOperatorAppIdpConfigRequestT = Model::UpdateOperatorAppIdpConfigRequest>
  Model::UpdateOperatorAppIdpConfigOutcomeCallable UpdateOperatorAppIdpConfigCallable(
      const UpdateOperatorAppIdpConfigRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::UpdateOperatorAppIdpConfig, request);
  }
 
  template <typename UpdateOperatorAppIdpConfigRequestT = Model::UpdateOperatorAppIdpConfigRequest>
  void UpdateOperatorAppIdpConfigAsync(const UpdateOperatorAppIdpConfigRequestT& request,
                                       const UpdateOperatorAppIdpConfigResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::UpdateOperatorAppIdpConfig, request, handler, context);
  }
 
  virtual Model::UpdatePrivateConnectionCertificateOutcome UpdatePrivateConnectionCertificate(
      const Model::UpdatePrivateConnectionCertificateRequest& request) const;
 
  template <typename UpdatePrivateConnectionCertificateRequestT = Model::UpdatePrivateConnectionCertificateRequest>
  Model::UpdatePrivateConnectionCertificateOutcomeCallable UpdatePrivateConnectionCertificateCallable(
      const UpdatePrivateConnectionCertificateRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::UpdatePrivateConnectionCertificate, request);
  }
 
  template <typename UpdatePrivateConnectionCertificateRequestT = Model::UpdatePrivateConnectionCertificateRequest>
  void UpdatePrivateConnectionCertificateAsync(const UpdatePrivateConnectionCertificateRequestT& request,
                                               const UpdatePrivateConnectionCertificateResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::UpdatePrivateConnectionCertificate, request, handler, context);
  }
 
  virtual Model::UpdateRecommendationOutcome UpdateRecommendation(const Model::UpdateRecommendationRequest& request) const;
 
  template <typename UpdateRecommendationRequestT = Model::UpdateRecommendationRequest>
  Model::UpdateRecommendationOutcomeCallable UpdateRecommendationCallable(const UpdateRecommendationRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::UpdateRecommendation, request);
  }
 
  template <typename UpdateRecommendationRequestT = Model::UpdateRecommendationRequest>
  void UpdateRecommendationAsync(const UpdateRecommendationRequestT& request, const UpdateRecommendationResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::UpdateRecommendation, request, handler, context);
  }
 
  virtual Model::UpdateTriggerOutcome UpdateTrigger(const Model::UpdateTriggerRequest& request) const;
 
  template <typename UpdateTriggerRequestT = Model::UpdateTriggerRequest>
  Model::UpdateTriggerOutcomeCallable UpdateTriggerCallable(const UpdateTriggerRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::UpdateTrigger, request);
  }
 
  template <typename UpdateTriggerRequestT = Model::UpdateTriggerRequest>
  void UpdateTriggerAsync(const UpdateTriggerRequestT& request, const UpdateTriggerResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::UpdateTrigger, request, handler, context);
  }
 
  virtual Model::ValidateAwsAssociationsOutcome ValidateAwsAssociations(const Model::ValidateAwsAssociationsRequest& request) const;
 
  template <typename ValidateAwsAssociationsRequestT = Model::ValidateAwsAssociationsRequest>
  Model::ValidateAwsAssociationsOutcomeCallable ValidateAwsAssociationsCallable(const ValidateAwsAssociationsRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::ValidateAwsAssociations, request);
  }
 
  template <typename ValidateAwsAssociationsRequestT = Model::ValidateAwsAssociationsRequest>
  void ValidateAwsAssociationsAsync(const ValidateAwsAssociationsRequestT& request,
                                    const ValidateAwsAssociationsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::ValidateAwsAssociations, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<DevOpsAgentEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<DevOpsAgentClient>;
  void init(const DevOpsAgentClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, DevOpsAgentError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  DevOpsAgentClientConfiguration m_clientConfiguration;
  std::shared_ptr<DevOpsAgentEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace DevOpsAgent
}  // namespace Aws