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::AllowVendedLogDeliveryForResourceOutcome AllowVendedLogDeliveryForResource(
      const Model::AllowVendedLogDeliveryForResourceRequest& request) const;
 
  template <typename AllowVendedLogDeliveryForResourceRequestT = Model::AllowVendedLogDeliveryForResourceRequest>
  Model::AllowVendedLogDeliveryForResourceOutcomeCallable AllowVendedLogDeliveryForResourceCallable(
      const AllowVendedLogDeliveryForResourceRequestT& request) const {
    return SubmitCallable(&DevOpsAgentClient::AllowVendedLogDeliveryForResource, request);
  }
 
  template <typename AllowVendedLogDeliveryForResourceRequestT = Model::AllowVendedLogDeliveryForResourceRequest>
  void AllowVendedLogDeliveryForResourceAsync(const AllowVendedLogDeliveryForResourceRequestT& request,
                                              const AllowVendedLogDeliveryForResourceResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsAgentClient::AllowVendedLogDeliveryForResource, request, handler, context);
  }
 
  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::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::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::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::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::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::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::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::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::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::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