SecurityAgentClient.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/securityagent/SecurityAgentPaginationBase.h>
#include <aws/securityagent/SecurityAgentServiceClientModel.h>
#include <aws/securityagent/SecurityAgentWaiter.h>
#include <aws/securityagent/SecurityAgent_EXPORTS.h>
 
namespace Aws {
namespace SecurityAgent {
class AWS_SECURITYAGENT_API SecurityAgentClient : public Aws::Client::AWSJsonClient,
                                                  public Aws::Client::ClientWithAsyncTemplateMethods<SecurityAgentClient>,
                                                  public SecurityAgentPaginationBase<SecurityAgentClient>,
                                                  public SecurityAgentWaiter<SecurityAgentClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef SecurityAgentClientConfiguration ClientConfigurationType;
  typedef SecurityAgentEndpointProvider EndpointProviderType;
 
  SecurityAgentClient(const Aws::SecurityAgent::SecurityAgentClientConfiguration& clientConfiguration =
                          Aws::SecurityAgent::SecurityAgentClientConfiguration(),
                      std::shared_ptr<SecurityAgentEndpointProviderBase> endpointProvider = nullptr);
 
  SecurityAgentClient(const Aws::Auth::AWSCredentials& credentials,
                      std::shared_ptr<SecurityAgentEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::SecurityAgent::SecurityAgentClientConfiguration& clientConfiguration =
                          Aws::SecurityAgent::SecurityAgentClientConfiguration());
 
  SecurityAgentClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      std::shared_ptr<SecurityAgentEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::SecurityAgent::SecurityAgentClientConfiguration& clientConfiguration =
                          Aws::SecurityAgent::SecurityAgentClientConfiguration());
 
  /* Legacy constructors due deprecation */
  SecurityAgentClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SecurityAgentClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SecurityAgentClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~SecurityAgentClient();
 
  virtual Model::AddArtifactOutcome AddArtifact(const Model::AddArtifactRequest& request) const;
 
  template <typename AddArtifactRequestT = Model::AddArtifactRequest>
  Model::AddArtifactOutcomeCallable AddArtifactCallable(const AddArtifactRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::AddArtifact, request);
  }
 
  template <typename AddArtifactRequestT = Model::AddArtifactRequest>
  void AddArtifactAsync(const AddArtifactRequestT& request, const AddArtifactResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::AddArtifact, request, handler, context);
  }
 
  virtual Model::BatchDeletePentestsOutcome BatchDeletePentests(const Model::BatchDeletePentestsRequest& request) const;
 
  template <typename BatchDeletePentestsRequestT = Model::BatchDeletePentestsRequest>
  Model::BatchDeletePentestsOutcomeCallable BatchDeletePentestsCallable(const BatchDeletePentestsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::BatchDeletePentests, request);
  }
 
  template <typename BatchDeletePentestsRequestT = Model::BatchDeletePentestsRequest>
  void BatchDeletePentestsAsync(const BatchDeletePentestsRequestT& request, const BatchDeletePentestsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::BatchDeletePentests, request, handler, context);
  }
 
  virtual Model::BatchGetAgentSpacesOutcome BatchGetAgentSpaces(const Model::BatchGetAgentSpacesRequest& request) const;
 
  template <typename BatchGetAgentSpacesRequestT = Model::BatchGetAgentSpacesRequest>
  Model::BatchGetAgentSpacesOutcomeCallable BatchGetAgentSpacesCallable(const BatchGetAgentSpacesRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::BatchGetAgentSpaces, request);
  }
 
  template <typename BatchGetAgentSpacesRequestT = Model::BatchGetAgentSpacesRequest>
  void BatchGetAgentSpacesAsync(const BatchGetAgentSpacesRequestT& request, const BatchGetAgentSpacesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::BatchGetAgentSpaces, request, handler, context);
  }
 
  virtual Model::BatchGetArtifactMetadataOutcome BatchGetArtifactMetadata(const Model::BatchGetArtifactMetadataRequest& request) const;
 
  template <typename BatchGetArtifactMetadataRequestT = Model::BatchGetArtifactMetadataRequest>
  Model::BatchGetArtifactMetadataOutcomeCallable BatchGetArtifactMetadataCallable(const BatchGetArtifactMetadataRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::BatchGetArtifactMetadata, request);
  }
 
  template <typename BatchGetArtifactMetadataRequestT = Model::BatchGetArtifactMetadataRequest>
  void BatchGetArtifactMetadataAsync(const BatchGetArtifactMetadataRequestT& request,
                                     const BatchGetArtifactMetadataResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::BatchGetArtifactMetadata, request, handler, context);
  }
 
  virtual Model::BatchGetFindingsOutcome BatchGetFindings(const Model::BatchGetFindingsRequest& request) const;
 
  template <typename BatchGetFindingsRequestT = Model::BatchGetFindingsRequest>
  Model::BatchGetFindingsOutcomeCallable BatchGetFindingsCallable(const BatchGetFindingsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::BatchGetFindings, request);
  }
 
  template <typename BatchGetFindingsRequestT = Model::BatchGetFindingsRequest>
  void BatchGetFindingsAsync(const BatchGetFindingsRequestT& request, const BatchGetFindingsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::BatchGetFindings, request, handler, context);
  }
 
  virtual Model::BatchGetPentestJobTasksOutcome BatchGetPentestJobTasks(const Model::BatchGetPentestJobTasksRequest& request) const;
 
  template <typename BatchGetPentestJobTasksRequestT = Model::BatchGetPentestJobTasksRequest>
  Model::BatchGetPentestJobTasksOutcomeCallable BatchGetPentestJobTasksCallable(const BatchGetPentestJobTasksRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::BatchGetPentestJobTasks, request);
  }
 
  template <typename BatchGetPentestJobTasksRequestT = Model::BatchGetPentestJobTasksRequest>
  void BatchGetPentestJobTasksAsync(const BatchGetPentestJobTasksRequestT& request,
                                    const BatchGetPentestJobTasksResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::BatchGetPentestJobTasks, request, handler, context);
  }
 
  virtual Model::BatchGetPentestJobsOutcome BatchGetPentestJobs(const Model::BatchGetPentestJobsRequest& request) const;
 
  template <typename BatchGetPentestJobsRequestT = Model::BatchGetPentestJobsRequest>
  Model::BatchGetPentestJobsOutcomeCallable BatchGetPentestJobsCallable(const BatchGetPentestJobsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::BatchGetPentestJobs, request);
  }
 
  template <typename BatchGetPentestJobsRequestT = Model::BatchGetPentestJobsRequest>
  void BatchGetPentestJobsAsync(const BatchGetPentestJobsRequestT& request, const BatchGetPentestJobsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::BatchGetPentestJobs, request, handler, context);
  }
 
  virtual Model::BatchGetPentestsOutcome BatchGetPentests(const Model::BatchGetPentestsRequest& request) const;
 
  template <typename BatchGetPentestsRequestT = Model::BatchGetPentestsRequest>
  Model::BatchGetPentestsOutcomeCallable BatchGetPentestsCallable(const BatchGetPentestsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::BatchGetPentests, request);
  }
 
  template <typename BatchGetPentestsRequestT = Model::BatchGetPentestsRequest>
  void BatchGetPentestsAsync(const BatchGetPentestsRequestT& request, const BatchGetPentestsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::BatchGetPentests, request, handler, context);
  }
 
  virtual Model::BatchGetTargetDomainsOutcome BatchGetTargetDomains(const Model::BatchGetTargetDomainsRequest& request) const;
 
  template <typename BatchGetTargetDomainsRequestT = Model::BatchGetTargetDomainsRequest>
  Model::BatchGetTargetDomainsOutcomeCallable BatchGetTargetDomainsCallable(const BatchGetTargetDomainsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::BatchGetTargetDomains, request);
  }
 
  template <typename BatchGetTargetDomainsRequestT = Model::BatchGetTargetDomainsRequest>
  void BatchGetTargetDomainsAsync(const BatchGetTargetDomainsRequestT& request, const BatchGetTargetDomainsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::BatchGetTargetDomains, 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(&SecurityAgentClient::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(&SecurityAgentClient::CreateAgentSpace, request, handler, context);
  }
 
  virtual Model::CreateApplicationOutcome CreateApplication(const Model::CreateApplicationRequest& request = {}) const;
 
  template <typename CreateApplicationRequestT = Model::CreateApplicationRequest>
  Model::CreateApplicationOutcomeCallable CreateApplicationCallable(const CreateApplicationRequestT& request = {}) const {
    return SubmitCallable(&SecurityAgentClient::CreateApplication, request);
  }
 
  template <typename CreateApplicationRequestT = Model::CreateApplicationRequest>
  void CreateApplicationAsync(const CreateApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const CreateApplicationRequestT& request = {}) const {
    return SubmitAsync(&SecurityAgentClient::CreateApplication, request, handler, context);
  }
 
  virtual Model::CreateIntegrationOutcome CreateIntegration(const Model::CreateIntegrationRequest& request) const;
 
  template <typename CreateIntegrationRequestT = Model::CreateIntegrationRequest>
  Model::CreateIntegrationOutcomeCallable CreateIntegrationCallable(const CreateIntegrationRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::CreateIntegration, request);
  }
 
  template <typename CreateIntegrationRequestT = Model::CreateIntegrationRequest>
  void CreateIntegrationAsync(const CreateIntegrationRequestT& request, const CreateIntegrationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::CreateIntegration, request, handler, context);
  }
 
  virtual Model::CreateMembershipOutcome CreateMembership(const Model::CreateMembershipRequest& request) const;
 
  template <typename CreateMembershipRequestT = Model::CreateMembershipRequest>
  Model::CreateMembershipOutcomeCallable CreateMembershipCallable(const CreateMembershipRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::CreateMembership, request);
  }
 
  template <typename CreateMembershipRequestT = Model::CreateMembershipRequest>
  void CreateMembershipAsync(const CreateMembershipRequestT& request, const CreateMembershipResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::CreateMembership, request, handler, context);
  }
 
  virtual Model::CreatePentestOutcome CreatePentest(const Model::CreatePentestRequest& request) const;
 
  template <typename CreatePentestRequestT = Model::CreatePentestRequest>
  Model::CreatePentestOutcomeCallable CreatePentestCallable(const CreatePentestRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::CreatePentest, request);
  }
 
  template <typename CreatePentestRequestT = Model::CreatePentestRequest>
  void CreatePentestAsync(const CreatePentestRequestT& request, const CreatePentestResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::CreatePentest, request, handler, context);
  }
 
  virtual Model::CreateTargetDomainOutcome CreateTargetDomain(const Model::CreateTargetDomainRequest& request) const;
 
  template <typename CreateTargetDomainRequestT = Model::CreateTargetDomainRequest>
  Model::CreateTargetDomainOutcomeCallable CreateTargetDomainCallable(const CreateTargetDomainRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::CreateTargetDomain, request);
  }
 
  template <typename CreateTargetDomainRequestT = Model::CreateTargetDomainRequest>
  void CreateTargetDomainAsync(const CreateTargetDomainRequestT& request, const CreateTargetDomainResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::CreateTargetDomain, 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(&SecurityAgentClient::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(&SecurityAgentClient::DeleteAgentSpace, request, handler, context);
  }
 
  virtual Model::DeleteApplicationOutcome DeleteApplication(const Model::DeleteApplicationRequest& request) const;
 
  template <typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
  Model::DeleteApplicationOutcomeCallable DeleteApplicationCallable(const DeleteApplicationRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::DeleteApplication, request);
  }
 
  template <typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
  void DeleteApplicationAsync(const DeleteApplicationRequestT& request, const DeleteApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::DeleteApplication, request, handler, context);
  }
 
  virtual Model::DeleteArtifactOutcome DeleteArtifact(const Model::DeleteArtifactRequest& request) const;
 
  template <typename DeleteArtifactRequestT = Model::DeleteArtifactRequest>
  Model::DeleteArtifactOutcomeCallable DeleteArtifactCallable(const DeleteArtifactRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::DeleteArtifact, request);
  }
 
  template <typename DeleteArtifactRequestT = Model::DeleteArtifactRequest>
  void DeleteArtifactAsync(const DeleteArtifactRequestT& request, const DeleteArtifactResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::DeleteArtifact, request, handler, context);
  }
 
  virtual Model::DeleteIntegrationOutcome DeleteIntegration(const Model::DeleteIntegrationRequest& request) const;
 
  template <typename DeleteIntegrationRequestT = Model::DeleteIntegrationRequest>
  Model::DeleteIntegrationOutcomeCallable DeleteIntegrationCallable(const DeleteIntegrationRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::DeleteIntegration, request);
  }
 
  template <typename DeleteIntegrationRequestT = Model::DeleteIntegrationRequest>
  void DeleteIntegrationAsync(const DeleteIntegrationRequestT& request, const DeleteIntegrationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::DeleteIntegration, request, handler, context);
  }
 
  virtual Model::DeleteMembershipOutcome DeleteMembership(const Model::DeleteMembershipRequest& request) const;
 
  template <typename DeleteMembershipRequestT = Model::DeleteMembershipRequest>
  Model::DeleteMembershipOutcomeCallable DeleteMembershipCallable(const DeleteMembershipRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::DeleteMembership, request);
  }
 
  template <typename DeleteMembershipRequestT = Model::DeleteMembershipRequest>
  void DeleteMembershipAsync(const DeleteMembershipRequestT& request, const DeleteMembershipResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::DeleteMembership, request, handler, context);
  }
 
  virtual Model::DeleteTargetDomainOutcome DeleteTargetDomain(const Model::DeleteTargetDomainRequest& request) const;
 
  template <typename DeleteTargetDomainRequestT = Model::DeleteTargetDomainRequest>
  Model::DeleteTargetDomainOutcomeCallable DeleteTargetDomainCallable(const DeleteTargetDomainRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::DeleteTargetDomain, request);
  }
 
  template <typename DeleteTargetDomainRequestT = Model::DeleteTargetDomainRequest>
  void DeleteTargetDomainAsync(const DeleteTargetDomainRequestT& request, const DeleteTargetDomainResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::DeleteTargetDomain, request, handler, context);
  }
 
  virtual Model::GetApplicationOutcome GetApplication(const Model::GetApplicationRequest& request) const;
 
  template <typename GetApplicationRequestT = Model::GetApplicationRequest>
  Model::GetApplicationOutcomeCallable GetApplicationCallable(const GetApplicationRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::GetApplication, request);
  }
 
  template <typename GetApplicationRequestT = Model::GetApplicationRequest>
  void GetApplicationAsync(const GetApplicationRequestT& request, const GetApplicationResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::GetApplication, request, handler, context);
  }
 
  virtual Model::GetArtifactOutcome GetArtifact(const Model::GetArtifactRequest& request) const;
 
  template <typename GetArtifactRequestT = Model::GetArtifactRequest>
  Model::GetArtifactOutcomeCallable GetArtifactCallable(const GetArtifactRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::GetArtifact, request);
  }
 
  template <typename GetArtifactRequestT = Model::GetArtifactRequest>
  void GetArtifactAsync(const GetArtifactRequestT& request, const GetArtifactResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::GetArtifact, request, handler, context);
  }
 
  virtual Model::GetIntegrationOutcome GetIntegration(const Model::GetIntegrationRequest& request) const;
 
  template <typename GetIntegrationRequestT = Model::GetIntegrationRequest>
  Model::GetIntegrationOutcomeCallable GetIntegrationCallable(const GetIntegrationRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::GetIntegration, request);
  }
 
  template <typename GetIntegrationRequestT = Model::GetIntegrationRequest>
  void GetIntegrationAsync(const GetIntegrationRequestT& request, const GetIntegrationResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::GetIntegration, request, handler, context);
  }
 
  virtual Model::InitiateProviderRegistrationOutcome InitiateProviderRegistration(
      const Model::InitiateProviderRegistrationRequest& request) const;
 
  template <typename InitiateProviderRegistrationRequestT = Model::InitiateProviderRegistrationRequest>
  Model::InitiateProviderRegistrationOutcomeCallable InitiateProviderRegistrationCallable(
      const InitiateProviderRegistrationRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::InitiateProviderRegistration, request);
  }
 
  template <typename InitiateProviderRegistrationRequestT = Model::InitiateProviderRegistrationRequest>
  void InitiateProviderRegistrationAsync(const InitiateProviderRegistrationRequestT& request,
                                         const InitiateProviderRegistrationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::InitiateProviderRegistration, 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(&SecurityAgentClient::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(&SecurityAgentClient::ListAgentSpaces, request, handler, context);
  }
 
  virtual Model::ListApplicationsOutcome ListApplications(const Model::ListApplicationsRequest& request = {}) const;
 
  template <typename ListApplicationsRequestT = Model::ListApplicationsRequest>
  Model::ListApplicationsOutcomeCallable ListApplicationsCallable(const ListApplicationsRequestT& request = {}) const {
    return SubmitCallable(&SecurityAgentClient::ListApplications, request);
  }
 
  template <typename ListApplicationsRequestT = Model::ListApplicationsRequest>
  void ListApplicationsAsync(const ListApplicationsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListApplicationsRequestT& request = {}) const {
    return SubmitAsync(&SecurityAgentClient::ListApplications, request, handler, context);
  }
 
  virtual Model::ListArtifactsOutcome ListArtifacts(const Model::ListArtifactsRequest& request) const;
 
  template <typename ListArtifactsRequestT = Model::ListArtifactsRequest>
  Model::ListArtifactsOutcomeCallable ListArtifactsCallable(const ListArtifactsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::ListArtifacts, request);
  }
 
  template <typename ListArtifactsRequestT = Model::ListArtifactsRequest>
  void ListArtifactsAsync(const ListArtifactsRequestT& request, const ListArtifactsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::ListArtifacts, request, handler, context);
  }
 
  virtual Model::ListDiscoveredEndpointsOutcome ListDiscoveredEndpoints(const Model::ListDiscoveredEndpointsRequest& request) const;
 
  template <typename ListDiscoveredEndpointsRequestT = Model::ListDiscoveredEndpointsRequest>
  Model::ListDiscoveredEndpointsOutcomeCallable ListDiscoveredEndpointsCallable(const ListDiscoveredEndpointsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::ListDiscoveredEndpoints, request);
  }
 
  template <typename ListDiscoveredEndpointsRequestT = Model::ListDiscoveredEndpointsRequest>
  void ListDiscoveredEndpointsAsync(const ListDiscoveredEndpointsRequestT& request,
                                    const ListDiscoveredEndpointsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::ListDiscoveredEndpoints, request, handler, context);
  }
 
  virtual Model::ListFindingsOutcome ListFindings(const Model::ListFindingsRequest& request) const;
 
  template <typename ListFindingsRequestT = Model::ListFindingsRequest>
  Model::ListFindingsOutcomeCallable ListFindingsCallable(const ListFindingsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::ListFindings, request);
  }
 
  template <typename ListFindingsRequestT = Model::ListFindingsRequest>
  void ListFindingsAsync(const ListFindingsRequestT& request, const ListFindingsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::ListFindings, request, handler, context);
  }
 
  virtual Model::ListIntegratedResourcesOutcome ListIntegratedResources(const Model::ListIntegratedResourcesRequest& request) const;
 
  template <typename ListIntegratedResourcesRequestT = Model::ListIntegratedResourcesRequest>
  Model::ListIntegratedResourcesOutcomeCallable ListIntegratedResourcesCallable(const ListIntegratedResourcesRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::ListIntegratedResources, request);
  }
 
  template <typename ListIntegratedResourcesRequestT = Model::ListIntegratedResourcesRequest>
  void ListIntegratedResourcesAsync(const ListIntegratedResourcesRequestT& request,
                                    const ListIntegratedResourcesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::ListIntegratedResources, request, handler, context);
  }
 
  virtual Model::ListIntegrationsOutcome ListIntegrations(const Model::ListIntegrationsRequest& request = {}) const;
 
  template <typename ListIntegrationsRequestT = Model::ListIntegrationsRequest>
  Model::ListIntegrationsOutcomeCallable ListIntegrationsCallable(const ListIntegrationsRequestT& request = {}) const {
    return SubmitCallable(&SecurityAgentClient::ListIntegrations, request);
  }
 
  template <typename ListIntegrationsRequestT = Model::ListIntegrationsRequest>
  void ListIntegrationsAsync(const ListIntegrationsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListIntegrationsRequestT& request = {}) const {
    return SubmitAsync(&SecurityAgentClient::ListIntegrations, request, handler, context);
  }
 
  virtual Model::ListMembershipsOutcome ListMemberships(const Model::ListMembershipsRequest& request) const;
 
  template <typename ListMembershipsRequestT = Model::ListMembershipsRequest>
  Model::ListMembershipsOutcomeCallable ListMembershipsCallable(const ListMembershipsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::ListMemberships, request);
  }
 
  template <typename ListMembershipsRequestT = Model::ListMembershipsRequest>
  void ListMembershipsAsync(const ListMembershipsRequestT& request, const ListMembershipsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::ListMemberships, request, handler, context);
  }
 
  virtual Model::ListPentestJobTasksOutcome ListPentestJobTasks(const Model::ListPentestJobTasksRequest& request) const;
 
  template <typename ListPentestJobTasksRequestT = Model::ListPentestJobTasksRequest>
  Model::ListPentestJobTasksOutcomeCallable ListPentestJobTasksCallable(const ListPentestJobTasksRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::ListPentestJobTasks, request);
  }
 
  template <typename ListPentestJobTasksRequestT = Model::ListPentestJobTasksRequest>
  void ListPentestJobTasksAsync(const ListPentestJobTasksRequestT& request, const ListPentestJobTasksResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::ListPentestJobTasks, request, handler, context);
  }
 
  virtual Model::ListPentestJobsForPentestOutcome ListPentestJobsForPentest(const Model::ListPentestJobsForPentestRequest& request) const;
 
  template <typename ListPentestJobsForPentestRequestT = Model::ListPentestJobsForPentestRequest>
  Model::ListPentestJobsForPentestOutcomeCallable ListPentestJobsForPentestCallable(
      const ListPentestJobsForPentestRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::ListPentestJobsForPentest, request);
  }
 
  template <typename ListPentestJobsForPentestRequestT = Model::ListPentestJobsForPentestRequest>
  void ListPentestJobsForPentestAsync(const ListPentestJobsForPentestRequestT& request,
                                      const ListPentestJobsForPentestResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::ListPentestJobsForPentest, request, handler, context);
  }
 
  virtual Model::ListPentestsOutcome ListPentests(const Model::ListPentestsRequest& request) const;
 
  template <typename ListPentestsRequestT = Model::ListPentestsRequest>
  Model::ListPentestsOutcomeCallable ListPentestsCallable(const ListPentestsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::ListPentests, request);
  }
 
  template <typename ListPentestsRequestT = Model::ListPentestsRequest>
  void ListPentestsAsync(const ListPentestsRequestT& request, const ListPentestsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::ListPentests, 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(&SecurityAgentClient::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(&SecurityAgentClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTargetDomainsOutcome ListTargetDomains(const Model::ListTargetDomainsRequest& request = {}) const;
 
  template <typename ListTargetDomainsRequestT = Model::ListTargetDomainsRequest>
  Model::ListTargetDomainsOutcomeCallable ListTargetDomainsCallable(const ListTargetDomainsRequestT& request = {}) const {
    return SubmitCallable(&SecurityAgentClient::ListTargetDomains, request);
  }
 
  template <typename ListTargetDomainsRequestT = Model::ListTargetDomainsRequest>
  void ListTargetDomainsAsync(const ListTargetDomainsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListTargetDomainsRequestT& request = {}) const {
    return SubmitAsync(&SecurityAgentClient::ListTargetDomains, request, handler, context);
  }
 
  virtual Model::StartCodeRemediationOutcome StartCodeRemediation(const Model::StartCodeRemediationRequest& request) const;
 
  template <typename StartCodeRemediationRequestT = Model::StartCodeRemediationRequest>
  Model::StartCodeRemediationOutcomeCallable StartCodeRemediationCallable(const StartCodeRemediationRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::StartCodeRemediation, request);
  }
 
  template <typename StartCodeRemediationRequestT = Model::StartCodeRemediationRequest>
  void StartCodeRemediationAsync(const StartCodeRemediationRequestT& request, const StartCodeRemediationResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::StartCodeRemediation, request, handler, context);
  }
 
  virtual Model::StartPentestJobOutcome StartPentestJob(const Model::StartPentestJobRequest& request) const;
 
  template <typename StartPentestJobRequestT = Model::StartPentestJobRequest>
  Model::StartPentestJobOutcomeCallable StartPentestJobCallable(const StartPentestJobRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::StartPentestJob, request);
  }
 
  template <typename StartPentestJobRequestT = Model::StartPentestJobRequest>
  void StartPentestJobAsync(const StartPentestJobRequestT& request, const StartPentestJobResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::StartPentestJob, request, handler, context);
  }
 
  virtual Model::StopPentestJobOutcome StopPentestJob(const Model::StopPentestJobRequest& request) const;
 
  template <typename StopPentestJobRequestT = Model::StopPentestJobRequest>
  Model::StopPentestJobOutcomeCallable StopPentestJobCallable(const StopPentestJobRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::StopPentestJob, request);
  }
 
  template <typename StopPentestJobRequestT = Model::StopPentestJobRequest>
  void StopPentestJobAsync(const StopPentestJobRequestT& request, const StopPentestJobResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::StopPentestJob, 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(&SecurityAgentClient::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(&SecurityAgentClient::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(&SecurityAgentClient::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(&SecurityAgentClient::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(&SecurityAgentClient::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(&SecurityAgentClient::UpdateAgentSpace, request, handler, context);
  }
 
  virtual Model::UpdateApplicationOutcome UpdateApplication(const Model::UpdateApplicationRequest& request) const;
 
  template <typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
  Model::UpdateApplicationOutcomeCallable UpdateApplicationCallable(const UpdateApplicationRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::UpdateApplication, request);
  }
 
  template <typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
  void UpdateApplicationAsync(const UpdateApplicationRequestT& request, const UpdateApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::UpdateApplication, request, handler, context);
  }
 
  virtual Model::UpdateFindingOutcome UpdateFinding(const Model::UpdateFindingRequest& request) const;
 
  template <typename UpdateFindingRequestT = Model::UpdateFindingRequest>
  Model::UpdateFindingOutcomeCallable UpdateFindingCallable(const UpdateFindingRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::UpdateFinding, request);
  }
 
  template <typename UpdateFindingRequestT = Model::UpdateFindingRequest>
  void UpdateFindingAsync(const UpdateFindingRequestT& request, const UpdateFindingResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::UpdateFinding, request, handler, context);
  }
 
  virtual Model::UpdateIntegratedResourcesOutcome UpdateIntegratedResources(const Model::UpdateIntegratedResourcesRequest& request) const;
 
  template <typename UpdateIntegratedResourcesRequestT = Model::UpdateIntegratedResourcesRequest>
  Model::UpdateIntegratedResourcesOutcomeCallable UpdateIntegratedResourcesCallable(
      const UpdateIntegratedResourcesRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::UpdateIntegratedResources, request);
  }
 
  template <typename UpdateIntegratedResourcesRequestT = Model::UpdateIntegratedResourcesRequest>
  void UpdateIntegratedResourcesAsync(const UpdateIntegratedResourcesRequestT& request,
                                      const UpdateIntegratedResourcesResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::UpdateIntegratedResources, request, handler, context);
  }
 
  virtual Model::UpdatePentestOutcome UpdatePentest(const Model::UpdatePentestRequest& request) const;
 
  template <typename UpdatePentestRequestT = Model::UpdatePentestRequest>
  Model::UpdatePentestOutcomeCallable UpdatePentestCallable(const UpdatePentestRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::UpdatePentest, request);
  }
 
  template <typename UpdatePentestRequestT = Model::UpdatePentestRequest>
  void UpdatePentestAsync(const UpdatePentestRequestT& request, const UpdatePentestResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::UpdatePentest, request, handler, context);
  }
 
  virtual Model::UpdateTargetDomainOutcome UpdateTargetDomain(const Model::UpdateTargetDomainRequest& request) const;
 
  template <typename UpdateTargetDomainRequestT = Model::UpdateTargetDomainRequest>
  Model::UpdateTargetDomainOutcomeCallable UpdateTargetDomainCallable(const UpdateTargetDomainRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::UpdateTargetDomain, request);
  }
 
  template <typename UpdateTargetDomainRequestT = Model::UpdateTargetDomainRequest>
  void UpdateTargetDomainAsync(const UpdateTargetDomainRequestT& request, const UpdateTargetDomainResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::UpdateTargetDomain, request, handler, context);
  }
 
  virtual Model::VerifyTargetDomainOutcome VerifyTargetDomain(const Model::VerifyTargetDomainRequest& request) const;
 
  template <typename VerifyTargetDomainRequestT = Model::VerifyTargetDomainRequest>
  Model::VerifyTargetDomainOutcomeCallable VerifyTargetDomainCallable(const VerifyTargetDomainRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::VerifyTargetDomain, request);
  }
 
  template <typename VerifyTargetDomainRequestT = Model::VerifyTargetDomainRequest>
  void VerifyTargetDomainAsync(const VerifyTargetDomainRequestT& request, const VerifyTargetDomainResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::VerifyTargetDomain, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<SecurityAgentEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<SecurityAgentClient>;
  void init(const SecurityAgentClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, SecurityAgentError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  SecurityAgentClientConfiguration m_clientConfiguration;
  std::shared_ptr<SecurityAgentEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace SecurityAgent
}  // namespace Aws