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::BatchCreateSecurityRequirementsOutcome BatchCreateSecurityRequirements(
      const Model::BatchCreateSecurityRequirementsRequest& request) const;
 
  template <typename BatchCreateSecurityRequirementsRequestT = Model::BatchCreateSecurityRequirementsRequest>
  Model::BatchCreateSecurityRequirementsOutcomeCallable BatchCreateSecurityRequirementsCallable(
      const BatchCreateSecurityRequirementsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::BatchCreateSecurityRequirements, request);
  }
 
  template <typename BatchCreateSecurityRequirementsRequestT = Model::BatchCreateSecurityRequirementsRequest>
  void BatchCreateSecurityRequirementsAsync(const BatchCreateSecurityRequirementsRequestT& request,
                                            const BatchCreateSecurityRequirementsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::BatchCreateSecurityRequirements, request, handler, context);
  }
 
  virtual Model::BatchDeleteCodeReviewsOutcome BatchDeleteCodeReviews(const Model::BatchDeleteCodeReviewsRequest& request) const;
 
  template <typename BatchDeleteCodeReviewsRequestT = Model::BatchDeleteCodeReviewsRequest>
  Model::BatchDeleteCodeReviewsOutcomeCallable BatchDeleteCodeReviewsCallable(const BatchDeleteCodeReviewsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::BatchDeleteCodeReviews, request);
  }
 
  template <typename BatchDeleteCodeReviewsRequestT = Model::BatchDeleteCodeReviewsRequest>
  void BatchDeleteCodeReviewsAsync(const BatchDeleteCodeReviewsRequestT& request,
                                   const BatchDeleteCodeReviewsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::BatchDeleteCodeReviews, 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::BatchDeleteSecurityRequirementsOutcome BatchDeleteSecurityRequirements(
      const Model::BatchDeleteSecurityRequirementsRequest& request) const;
 
  template <typename BatchDeleteSecurityRequirementsRequestT = Model::BatchDeleteSecurityRequirementsRequest>
  Model::BatchDeleteSecurityRequirementsOutcomeCallable BatchDeleteSecurityRequirementsCallable(
      const BatchDeleteSecurityRequirementsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::BatchDeleteSecurityRequirements, request);
  }
 
  template <typename BatchDeleteSecurityRequirementsRequestT = Model::BatchDeleteSecurityRequirementsRequest>
  void BatchDeleteSecurityRequirementsAsync(const BatchDeleteSecurityRequirementsRequestT& request,
                                            const BatchDeleteSecurityRequirementsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::BatchDeleteSecurityRequirements, request, handler, context);
  }
 
  virtual Model::BatchDeleteThreatModelsOutcome BatchDeleteThreatModels(const Model::BatchDeleteThreatModelsRequest& request) const;
 
  template <typename BatchDeleteThreatModelsRequestT = Model::BatchDeleteThreatModelsRequest>
  Model::BatchDeleteThreatModelsOutcomeCallable BatchDeleteThreatModelsCallable(const BatchDeleteThreatModelsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::BatchDeleteThreatModels, request);
  }
 
  template <typename BatchDeleteThreatModelsRequestT = Model::BatchDeleteThreatModelsRequest>
  void BatchDeleteThreatModelsAsync(const BatchDeleteThreatModelsRequestT& request,
                                    const BatchDeleteThreatModelsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::BatchDeleteThreatModels, request, handler, context);
  }
 
  virtual Model::BatchDisassociateFindingIssueOutcome BatchDisassociateFindingIssue(
      const Model::BatchDisassociateFindingIssueRequest& request) const;
 
  template <typename BatchDisassociateFindingIssueRequestT = Model::BatchDisassociateFindingIssueRequest>
  Model::BatchDisassociateFindingIssueOutcomeCallable BatchDisassociateFindingIssueCallable(
      const BatchDisassociateFindingIssueRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::BatchDisassociateFindingIssue, request);
  }
 
  template <typename BatchDisassociateFindingIssueRequestT = Model::BatchDisassociateFindingIssueRequest>
  void BatchDisassociateFindingIssueAsync(const BatchDisassociateFindingIssueRequestT& request,
                                          const BatchDisassociateFindingIssueResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::BatchDisassociateFindingIssue, request, handler, context);
  }
 
  virtual Model::BatchExportFindingsOutcome BatchExportFindings(const Model::BatchExportFindingsRequest& request) const;
 
  template <typename BatchExportFindingsRequestT = Model::BatchExportFindingsRequest>
  Model::BatchExportFindingsOutcomeCallable BatchExportFindingsCallable(const BatchExportFindingsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::BatchExportFindings, request);
  }
 
  template <typename BatchExportFindingsRequestT = Model::BatchExportFindingsRequest>
  void BatchExportFindingsAsync(const BatchExportFindingsRequestT& request, const BatchExportFindingsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::BatchExportFindings, 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::BatchGetCodeReviewJobTasksOutcome BatchGetCodeReviewJobTasks(
      const Model::BatchGetCodeReviewJobTasksRequest& request) const;
 
  template <typename BatchGetCodeReviewJobTasksRequestT = Model::BatchGetCodeReviewJobTasksRequest>
  Model::BatchGetCodeReviewJobTasksOutcomeCallable BatchGetCodeReviewJobTasksCallable(
      const BatchGetCodeReviewJobTasksRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::BatchGetCodeReviewJobTasks, request);
  }
 
  template <typename BatchGetCodeReviewJobTasksRequestT = Model::BatchGetCodeReviewJobTasksRequest>
  void BatchGetCodeReviewJobTasksAsync(const BatchGetCodeReviewJobTasksRequestT& request,
                                       const BatchGetCodeReviewJobTasksResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::BatchGetCodeReviewJobTasks, request, handler, context);
  }
 
  virtual Model::BatchGetCodeReviewJobsOutcome BatchGetCodeReviewJobs(const Model::BatchGetCodeReviewJobsRequest& request) const;
 
  template <typename BatchGetCodeReviewJobsRequestT = Model::BatchGetCodeReviewJobsRequest>
  Model::BatchGetCodeReviewJobsOutcomeCallable BatchGetCodeReviewJobsCallable(const BatchGetCodeReviewJobsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::BatchGetCodeReviewJobs, request);
  }
 
  template <typename BatchGetCodeReviewJobsRequestT = Model::BatchGetCodeReviewJobsRequest>
  void BatchGetCodeReviewJobsAsync(const BatchGetCodeReviewJobsRequestT& request,
                                   const BatchGetCodeReviewJobsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::BatchGetCodeReviewJobs, request, handler, context);
  }
 
  virtual Model::BatchGetCodeReviewsOutcome BatchGetCodeReviews(const Model::BatchGetCodeReviewsRequest& request) const;
 
  template <typename BatchGetCodeReviewsRequestT = Model::BatchGetCodeReviewsRequest>
  Model::BatchGetCodeReviewsOutcomeCallable BatchGetCodeReviewsCallable(const BatchGetCodeReviewsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::BatchGetCodeReviews, request);
  }
 
  template <typename BatchGetCodeReviewsRequestT = Model::BatchGetCodeReviewsRequest>
  void BatchGetCodeReviewsAsync(const BatchGetCodeReviewsRequestT& request, const BatchGetCodeReviewsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::BatchGetCodeReviews, 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::BatchGetSecurityRequirementsOutcome BatchGetSecurityRequirements(
      const Model::BatchGetSecurityRequirementsRequest& request) const;
 
  template <typename BatchGetSecurityRequirementsRequestT = Model::BatchGetSecurityRequirementsRequest>
  Model::BatchGetSecurityRequirementsOutcomeCallable BatchGetSecurityRequirementsCallable(
      const BatchGetSecurityRequirementsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::BatchGetSecurityRequirements, request);
  }
 
  template <typename BatchGetSecurityRequirementsRequestT = Model::BatchGetSecurityRequirementsRequest>
  void BatchGetSecurityRequirementsAsync(const BatchGetSecurityRequirementsRequestT& request,
                                         const BatchGetSecurityRequirementsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::BatchGetSecurityRequirements, 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::BatchGetThreatModelJobTasksOutcome BatchGetThreatModelJobTasks(
      const Model::BatchGetThreatModelJobTasksRequest& request) const;
 
  template <typename BatchGetThreatModelJobTasksRequestT = Model::BatchGetThreatModelJobTasksRequest>
  Model::BatchGetThreatModelJobTasksOutcomeCallable BatchGetThreatModelJobTasksCallable(
      const BatchGetThreatModelJobTasksRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::BatchGetThreatModelJobTasks, request);
  }
 
  template <typename BatchGetThreatModelJobTasksRequestT = Model::BatchGetThreatModelJobTasksRequest>
  void BatchGetThreatModelJobTasksAsync(const BatchGetThreatModelJobTasksRequestT& request,
                                        const BatchGetThreatModelJobTasksResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::BatchGetThreatModelJobTasks, request, handler, context);
  }
 
  virtual Model::BatchGetThreatModelJobsOutcome BatchGetThreatModelJobs(const Model::BatchGetThreatModelJobsRequest& request) const;
 
  template <typename BatchGetThreatModelJobsRequestT = Model::BatchGetThreatModelJobsRequest>
  Model::BatchGetThreatModelJobsOutcomeCallable BatchGetThreatModelJobsCallable(const BatchGetThreatModelJobsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::BatchGetThreatModelJobs, request);
  }
 
  template <typename BatchGetThreatModelJobsRequestT = Model::BatchGetThreatModelJobsRequest>
  void BatchGetThreatModelJobsAsync(const BatchGetThreatModelJobsRequestT& request,
                                    const BatchGetThreatModelJobsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::BatchGetThreatModelJobs, request, handler, context);
  }
 
  virtual Model::BatchGetThreatModelsOutcome BatchGetThreatModels(const Model::BatchGetThreatModelsRequest& request) const;
 
  template <typename BatchGetThreatModelsRequestT = Model::BatchGetThreatModelsRequest>
  Model::BatchGetThreatModelsOutcomeCallable BatchGetThreatModelsCallable(const BatchGetThreatModelsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::BatchGetThreatModels, request);
  }
 
  template <typename BatchGetThreatModelsRequestT = Model::BatchGetThreatModelsRequest>
  void BatchGetThreatModelsAsync(const BatchGetThreatModelsRequestT& request, const BatchGetThreatModelsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::BatchGetThreatModels, request, handler, context);
  }
 
  virtual Model::BatchGetThreatsOutcome BatchGetThreats(const Model::BatchGetThreatsRequest& request) const;
 
  template <typename BatchGetThreatsRequestT = Model::BatchGetThreatsRequest>
  Model::BatchGetThreatsOutcomeCallable BatchGetThreatsCallable(const BatchGetThreatsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::BatchGetThreats, request);
  }
 
  template <typename BatchGetThreatsRequestT = Model::BatchGetThreatsRequest>
  void BatchGetThreatsAsync(const BatchGetThreatsRequestT& request, const BatchGetThreatsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::BatchGetThreats, request, handler, context);
  }
 
  virtual Model::BatchUpdateSecurityRequirementsOutcome BatchUpdateSecurityRequirements(
      const Model::BatchUpdateSecurityRequirementsRequest& request) const;
 
  template <typename BatchUpdateSecurityRequirementsRequestT = Model::BatchUpdateSecurityRequirementsRequest>
  Model::BatchUpdateSecurityRequirementsOutcomeCallable BatchUpdateSecurityRequirementsCallable(
      const BatchUpdateSecurityRequirementsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::BatchUpdateSecurityRequirements, request);
  }
 
  template <typename BatchUpdateSecurityRequirementsRequestT = Model::BatchUpdateSecurityRequirementsRequest>
  void BatchUpdateSecurityRequirementsAsync(const BatchUpdateSecurityRequirementsRequestT& request,
                                            const BatchUpdateSecurityRequirementsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::BatchUpdateSecurityRequirements, 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::CreateCodeReviewOutcome CreateCodeReview(const Model::CreateCodeReviewRequest& request) const;
 
  template <typename CreateCodeReviewRequestT = Model::CreateCodeReviewRequest>
  Model::CreateCodeReviewOutcomeCallable CreateCodeReviewCallable(const CreateCodeReviewRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::CreateCodeReview, request);
  }
 
  template <typename CreateCodeReviewRequestT = Model::CreateCodeReviewRequest>
  void CreateCodeReviewAsync(const CreateCodeReviewRequestT& request, const CreateCodeReviewResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::CreateCodeReview, 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::CreatePrivateConnectionOutcome CreatePrivateConnection(const Model::CreatePrivateConnectionRequest& request) const;
 
  template <typename CreatePrivateConnectionRequestT = Model::CreatePrivateConnectionRequest>
  Model::CreatePrivateConnectionOutcomeCallable CreatePrivateConnectionCallable(const CreatePrivateConnectionRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::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(&SecurityAgentClient::CreatePrivateConnection, request, handler, context);
  }
 
  virtual Model::CreateSecurityRequirementPackOutcome CreateSecurityRequirementPack(
      const Model::CreateSecurityRequirementPackRequest& request) const;
 
  template <typename CreateSecurityRequirementPackRequestT = Model::CreateSecurityRequirementPackRequest>
  Model::CreateSecurityRequirementPackOutcomeCallable CreateSecurityRequirementPackCallable(
      const CreateSecurityRequirementPackRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::CreateSecurityRequirementPack, request);
  }
 
  template <typename CreateSecurityRequirementPackRequestT = Model::CreateSecurityRequirementPackRequest>
  void CreateSecurityRequirementPackAsync(const CreateSecurityRequirementPackRequestT& request,
                                          const CreateSecurityRequirementPackResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::CreateSecurityRequirementPack, 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::CreateThreatOutcome CreateThreat(const Model::CreateThreatRequest& request) const;
 
  template <typename CreateThreatRequestT = Model::CreateThreatRequest>
  Model::CreateThreatOutcomeCallable CreateThreatCallable(const CreateThreatRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::CreateThreat, request);
  }
 
  template <typename CreateThreatRequestT = Model::CreateThreatRequest>
  void CreateThreatAsync(const CreateThreatRequestT& request, const CreateThreatResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::CreateThreat, request, handler, context);
  }
 
  virtual Model::CreateThreatModelOutcome CreateThreatModel(const Model::CreateThreatModelRequest& request) const;
 
  template <typename CreateThreatModelRequestT = Model::CreateThreatModelRequest>
  Model::CreateThreatModelOutcomeCallable CreateThreatModelCallable(const CreateThreatModelRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::CreateThreatModel, request);
  }
 
  template <typename CreateThreatModelRequestT = Model::CreateThreatModelRequest>
  void CreateThreatModelAsync(const CreateThreatModelRequestT& request, const CreateThreatModelResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::CreateThreatModel, 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::DeletePrivateConnectionOutcome DeletePrivateConnection(const Model::DeletePrivateConnectionRequest& request) const;
 
  template <typename DeletePrivateConnectionRequestT = Model::DeletePrivateConnectionRequest>
  Model::DeletePrivateConnectionOutcomeCallable DeletePrivateConnectionCallable(const DeletePrivateConnectionRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::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(&SecurityAgentClient::DeletePrivateConnection, request, handler, context);
  }
 
  virtual Model::DeleteSecurityRequirementPackOutcome DeleteSecurityRequirementPack(
      const Model::DeleteSecurityRequirementPackRequest& request) const;
 
  template <typename DeleteSecurityRequirementPackRequestT = Model::DeleteSecurityRequirementPackRequest>
  Model::DeleteSecurityRequirementPackOutcomeCallable DeleteSecurityRequirementPackCallable(
      const DeleteSecurityRequirementPackRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::DeleteSecurityRequirementPack, request);
  }
 
  template <typename DeleteSecurityRequirementPackRequestT = Model::DeleteSecurityRequirementPackRequest>
  void DeleteSecurityRequirementPackAsync(const DeleteSecurityRequirementPackRequestT& request,
                                          const DeleteSecurityRequirementPackResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::DeleteSecurityRequirementPack, 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::DescribePrivateConnectionOutcome DescribePrivateConnection(const Model::DescribePrivateConnectionRequest& request) const;
 
  template <typename DescribePrivateConnectionRequestT = Model::DescribePrivateConnectionRequest>
  Model::DescribePrivateConnectionOutcomeCallable DescribePrivateConnectionCallable(
      const DescribePrivateConnectionRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::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(&SecurityAgentClient::DescribePrivateConnection, 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::GetSecurityRequirementPackOutcome GetSecurityRequirementPack(
      const Model::GetSecurityRequirementPackRequest& request) const;
 
  template <typename GetSecurityRequirementPackRequestT = Model::GetSecurityRequirementPackRequest>
  Model::GetSecurityRequirementPackOutcomeCallable GetSecurityRequirementPackCallable(
      const GetSecurityRequirementPackRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::GetSecurityRequirementPack, request);
  }
 
  template <typename GetSecurityRequirementPackRequestT = Model::GetSecurityRequirementPackRequest>
  void GetSecurityRequirementPackAsync(const GetSecurityRequirementPackRequestT& request,
                                       const GetSecurityRequirementPackResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::GetSecurityRequirementPack, request, handler, context);
  }
 
  virtual Model::ImportSecurityRequirementsOutcome ImportSecurityRequirements(
      const Model::ImportSecurityRequirementsRequest& request) const;
 
  template <typename ImportSecurityRequirementsRequestT = Model::ImportSecurityRequirementsRequest>
  Model::ImportSecurityRequirementsOutcomeCallable ImportSecurityRequirementsCallable(
      const ImportSecurityRequirementsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::ImportSecurityRequirements, request);
  }
 
  template <typename ImportSecurityRequirementsRequestT = Model::ImportSecurityRequirementsRequest>
  void ImportSecurityRequirementsAsync(const ImportSecurityRequirementsRequestT& request,
                                       const ImportSecurityRequirementsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::ImportSecurityRequirements, 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::ListActorMessagesOutcome ListActorMessages(const Model::ListActorMessagesRequest& request) const;
 
  template <typename ListActorMessagesRequestT = Model::ListActorMessagesRequest>
  Model::ListActorMessagesOutcomeCallable ListActorMessagesCallable(const ListActorMessagesRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::ListActorMessages, request);
  }
 
  template <typename ListActorMessagesRequestT = Model::ListActorMessagesRequest>
  void ListActorMessagesAsync(const ListActorMessagesRequestT& request, const ListActorMessagesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::ListActorMessages, 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::ListCodeReviewJobTasksOutcome ListCodeReviewJobTasks(const Model::ListCodeReviewJobTasksRequest& request) const;
 
  template <typename ListCodeReviewJobTasksRequestT = Model::ListCodeReviewJobTasksRequest>
  Model::ListCodeReviewJobTasksOutcomeCallable ListCodeReviewJobTasksCallable(const ListCodeReviewJobTasksRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::ListCodeReviewJobTasks, request);
  }
 
  template <typename ListCodeReviewJobTasksRequestT = Model::ListCodeReviewJobTasksRequest>
  void ListCodeReviewJobTasksAsync(const ListCodeReviewJobTasksRequestT& request,
                                   const ListCodeReviewJobTasksResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::ListCodeReviewJobTasks, request, handler, context);
  }
 
  virtual Model::ListCodeReviewJobsForCodeReviewOutcome ListCodeReviewJobsForCodeReview(
      const Model::ListCodeReviewJobsForCodeReviewRequest& request) const;
 
  template <typename ListCodeReviewJobsForCodeReviewRequestT = Model::ListCodeReviewJobsForCodeReviewRequest>
  Model::ListCodeReviewJobsForCodeReviewOutcomeCallable ListCodeReviewJobsForCodeReviewCallable(
      const ListCodeReviewJobsForCodeReviewRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::ListCodeReviewJobsForCodeReview, request);
  }
 
  template <typename ListCodeReviewJobsForCodeReviewRequestT = Model::ListCodeReviewJobsForCodeReviewRequest>
  void ListCodeReviewJobsForCodeReviewAsync(const ListCodeReviewJobsForCodeReviewRequestT& request,
                                            const ListCodeReviewJobsForCodeReviewResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::ListCodeReviewJobsForCodeReview, request, handler, context);
  }
 
  virtual Model::ListCodeReviewsOutcome ListCodeReviews(const Model::ListCodeReviewsRequest& request) const;
 
  template <typename ListCodeReviewsRequestT = Model::ListCodeReviewsRequest>
  Model::ListCodeReviewsOutcomeCallable ListCodeReviewsCallable(const ListCodeReviewsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::ListCodeReviews, request);
  }
 
  template <typename ListCodeReviewsRequestT = Model::ListCodeReviewsRequest>
  void ListCodeReviewsAsync(const ListCodeReviewsRequestT& request, const ListCodeReviewsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::ListCodeReviews, 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::ListPrivateConnectionsOutcome ListPrivateConnections(const Model::ListPrivateConnectionsRequest& request = {}) const;
 
  template <typename ListPrivateConnectionsRequestT = Model::ListPrivateConnectionsRequest>
  Model::ListPrivateConnectionsOutcomeCallable ListPrivateConnectionsCallable(const ListPrivateConnectionsRequestT& request = {}) const {
    return SubmitCallable(&SecurityAgentClient::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(&SecurityAgentClient::ListPrivateConnections, request, handler, context);
  }
 
  virtual Model::ListSecurityRequirementPacksOutcome ListSecurityRequirementPacks(
      const Model::ListSecurityRequirementPacksRequest& request = {}) const;
 
  template <typename ListSecurityRequirementPacksRequestT = Model::ListSecurityRequirementPacksRequest>
  Model::ListSecurityRequirementPacksOutcomeCallable ListSecurityRequirementPacksCallable(
      const ListSecurityRequirementPacksRequestT& request = {}) const {
    return SubmitCallable(&SecurityAgentClient::ListSecurityRequirementPacks, request);
  }
 
  template <typename ListSecurityRequirementPacksRequestT = Model::ListSecurityRequirementPacksRequest>
  void ListSecurityRequirementPacksAsync(const ListSecurityRequirementPacksResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const ListSecurityRequirementPacksRequestT& request = {}) const {
    return SubmitAsync(&SecurityAgentClient::ListSecurityRequirementPacks, request, handler, context);
  }
 
  virtual Model::ListSecurityRequirementsOutcome ListSecurityRequirements(const Model::ListSecurityRequirementsRequest& request) const;
 
  template <typename ListSecurityRequirementsRequestT = Model::ListSecurityRequirementsRequest>
  Model::ListSecurityRequirementsOutcomeCallable ListSecurityRequirementsCallable(const ListSecurityRequirementsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::ListSecurityRequirements, request);
  }
 
  template <typename ListSecurityRequirementsRequestT = Model::ListSecurityRequirementsRequest>
  void ListSecurityRequirementsAsync(const ListSecurityRequirementsRequestT& request,
                                     const ListSecurityRequirementsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::ListSecurityRequirements, 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::ListThreatModelJobTasksOutcome ListThreatModelJobTasks(const Model::ListThreatModelJobTasksRequest& request) const;
 
  template <typename ListThreatModelJobTasksRequestT = Model::ListThreatModelJobTasksRequest>
  Model::ListThreatModelJobTasksOutcomeCallable ListThreatModelJobTasksCallable(const ListThreatModelJobTasksRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::ListThreatModelJobTasks, request);
  }
 
  template <typename ListThreatModelJobTasksRequestT = Model::ListThreatModelJobTasksRequest>
  void ListThreatModelJobTasksAsync(const ListThreatModelJobTasksRequestT& request,
                                    const ListThreatModelJobTasksResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::ListThreatModelJobTasks, request, handler, context);
  }
 
  virtual Model::ListThreatModelJobsOutcome ListThreatModelJobs(const Model::ListThreatModelJobsRequest& request) const;
 
  template <typename ListThreatModelJobsRequestT = Model::ListThreatModelJobsRequest>
  Model::ListThreatModelJobsOutcomeCallable ListThreatModelJobsCallable(const ListThreatModelJobsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::ListThreatModelJobs, request);
  }
 
  template <typename ListThreatModelJobsRequestT = Model::ListThreatModelJobsRequest>
  void ListThreatModelJobsAsync(const ListThreatModelJobsRequestT& request, const ListThreatModelJobsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::ListThreatModelJobs, request, handler, context);
  }
 
  virtual Model::ListThreatModelsOutcome ListThreatModels(const Model::ListThreatModelsRequest& request) const;
 
  template <typename ListThreatModelsRequestT = Model::ListThreatModelsRequest>
  Model::ListThreatModelsOutcomeCallable ListThreatModelsCallable(const ListThreatModelsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::ListThreatModels, request);
  }
 
  template <typename ListThreatModelsRequestT = Model::ListThreatModelsRequest>
  void ListThreatModelsAsync(const ListThreatModelsRequestT& request, const ListThreatModelsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::ListThreatModels, request, handler, context);
  }
 
  virtual Model::ListThreatsOutcome ListThreats(const Model::ListThreatsRequest& request) const;
 
  template <typename ListThreatsRequestT = Model::ListThreatsRequest>
  Model::ListThreatsOutcomeCallable ListThreatsCallable(const ListThreatsRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::ListThreats, request);
  }
 
  template <typename ListThreatsRequestT = Model::ListThreatsRequest>
  void ListThreatsAsync(const ListThreatsRequestT& request, const ListThreatsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::ListThreats, 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::StartCodeReviewJobOutcome StartCodeReviewJob(const Model::StartCodeReviewJobRequest& request) const;
 
  template <typename StartCodeReviewJobRequestT = Model::StartCodeReviewJobRequest>
  Model::StartCodeReviewJobOutcomeCallable StartCodeReviewJobCallable(const StartCodeReviewJobRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::StartCodeReviewJob, request);
  }
 
  template <typename StartCodeReviewJobRequestT = Model::StartCodeReviewJobRequest>
  void StartCodeReviewJobAsync(const StartCodeReviewJobRequestT& request, const StartCodeReviewJobResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::StartCodeReviewJob, 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::StartThreatModelJobOutcome StartThreatModelJob(const Model::StartThreatModelJobRequest& request) const;
 
  template <typename StartThreatModelJobRequestT = Model::StartThreatModelJobRequest>
  Model::StartThreatModelJobOutcomeCallable StartThreatModelJobCallable(const StartThreatModelJobRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::StartThreatModelJob, request);
  }
 
  template <typename StartThreatModelJobRequestT = Model::StartThreatModelJobRequest>
  void StartThreatModelJobAsync(const StartThreatModelJobRequestT& request, const StartThreatModelJobResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::StartThreatModelJob, request, handler, context);
  }
 
  virtual Model::StopCodeReviewJobOutcome StopCodeReviewJob(const Model::StopCodeReviewJobRequest& request) const;
 
  template <typename StopCodeReviewJobRequestT = Model::StopCodeReviewJobRequest>
  Model::StopCodeReviewJobOutcomeCallable StopCodeReviewJobCallable(const StopCodeReviewJobRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::StopCodeReviewJob, request);
  }
 
  template <typename StopCodeReviewJobRequestT = Model::StopCodeReviewJobRequest>
  void StopCodeReviewJobAsync(const StopCodeReviewJobRequestT& request, const StopCodeReviewJobResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::StopCodeReviewJob, 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::StopThreatModelJobOutcome StopThreatModelJob(const Model::StopThreatModelJobRequest& request) const;
 
  template <typename StopThreatModelJobRequestT = Model::StopThreatModelJobRequest>
  Model::StopThreatModelJobOutcomeCallable StopThreatModelJobCallable(const StopThreatModelJobRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::StopThreatModelJob, request);
  }
 
  template <typename StopThreatModelJobRequestT = Model::StopThreatModelJobRequest>
  void StopThreatModelJobAsync(const StopThreatModelJobRequestT& request, const StopThreatModelJobResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::StopThreatModelJob, 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::UpdateCodeReviewOutcome UpdateCodeReview(const Model::UpdateCodeReviewRequest& request) const;
 
  template <typename UpdateCodeReviewRequestT = Model::UpdateCodeReviewRequest>
  Model::UpdateCodeReviewOutcomeCallable UpdateCodeReviewCallable(const UpdateCodeReviewRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::UpdateCodeReview, request);
  }
 
  template <typename UpdateCodeReviewRequestT = Model::UpdateCodeReviewRequest>
  void UpdateCodeReviewAsync(const UpdateCodeReviewRequestT& request, const UpdateCodeReviewResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::UpdateCodeReview, 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::UpdateIntegrationOutcome UpdateIntegration(const Model::UpdateIntegrationRequest& request) const;
 
  template <typename UpdateIntegrationRequestT = Model::UpdateIntegrationRequest>
  Model::UpdateIntegrationOutcomeCallable UpdateIntegrationCallable(const UpdateIntegrationRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::UpdateIntegration, request);
  }
 
  template <typename UpdateIntegrationRequestT = Model::UpdateIntegrationRequest>
  void UpdateIntegrationAsync(const UpdateIntegrationRequestT& request, const UpdateIntegrationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::UpdateIntegration, 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::UpdatePrivateConnectionCertificateOutcome UpdatePrivateConnectionCertificate(
      const Model::UpdatePrivateConnectionCertificateRequest& request) const;
 
  template <typename UpdatePrivateConnectionCertificateRequestT = Model::UpdatePrivateConnectionCertificateRequest>
  Model::UpdatePrivateConnectionCertificateOutcomeCallable UpdatePrivateConnectionCertificateCallable(
      const UpdatePrivateConnectionCertificateRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::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(&SecurityAgentClient::UpdatePrivateConnectionCertificate, request, handler, context);
  }
 
  virtual Model::UpdateSecurityRequirementPackOutcome UpdateSecurityRequirementPack(
      const Model::UpdateSecurityRequirementPackRequest& request) const;
 
  template <typename UpdateSecurityRequirementPackRequestT = Model::UpdateSecurityRequirementPackRequest>
  Model::UpdateSecurityRequirementPackOutcomeCallable UpdateSecurityRequirementPackCallable(
      const UpdateSecurityRequirementPackRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::UpdateSecurityRequirementPack, request);
  }
 
  template <typename UpdateSecurityRequirementPackRequestT = Model::UpdateSecurityRequirementPackRequest>
  void UpdateSecurityRequirementPackAsync(const UpdateSecurityRequirementPackRequestT& request,
                                          const UpdateSecurityRequirementPackResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::UpdateSecurityRequirementPack, 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::UpdateThreatOutcome UpdateThreat(const Model::UpdateThreatRequest& request) const;
 
  template <typename UpdateThreatRequestT = Model::UpdateThreatRequest>
  Model::UpdateThreatOutcomeCallable UpdateThreatCallable(const UpdateThreatRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::UpdateThreat, request);
  }
 
  template <typename UpdateThreatRequestT = Model::UpdateThreatRequest>
  void UpdateThreatAsync(const UpdateThreatRequestT& request, const UpdateThreatResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::UpdateThreat, request, handler, context);
  }
 
  virtual Model::UpdateThreatModelOutcome UpdateThreatModel(const Model::UpdateThreatModelRequest& request) const;
 
  template <typename UpdateThreatModelRequestT = Model::UpdateThreatModelRequest>
  Model::UpdateThreatModelOutcomeCallable UpdateThreatModelCallable(const UpdateThreatModelRequestT& request) const {
    return SubmitCallable(&SecurityAgentClient::UpdateThreatModel, request);
  }
 
  template <typename UpdateThreatModelRequestT = Model::UpdateThreatModelRequest>
  void UpdateThreatModelAsync(const UpdateThreatModelRequestT& request, const UpdateThreatModelResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityAgentClient::UpdateThreatModel, 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