InspectorClient.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/inspector/InspectorPaginationBase.h>
#include <aws/inspector/InspectorServiceClientModel.h>
#include <aws/inspector/InspectorWaiter.h>
#include <aws/inspector/Inspector_EXPORTS.h>
 
namespace Aws {
namespace Inspector {
class AWS_INSPECTOR_API InspectorClient : public Aws::Client::AWSJsonClient,
                                          public Aws::Client::ClientWithAsyncTemplateMethods<InspectorClient>,
                                          public InspectorPaginationBase<InspectorClient>,
                                          public InspectorWaiter<InspectorClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef InspectorClientConfiguration ClientConfigurationType;
  typedef InspectorEndpointProvider EndpointProviderType;
 
  InspectorClient(const Aws::Inspector::InspectorClientConfiguration& clientConfiguration = Aws::Inspector::InspectorClientConfiguration(),
                  std::shared_ptr<InspectorEndpointProviderBase> endpointProvider = nullptr);
 
  InspectorClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<InspectorEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::Inspector::InspectorClientConfiguration& clientConfiguration = Aws::Inspector::InspectorClientConfiguration());
 
  InspectorClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<InspectorEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::Inspector::InspectorClientConfiguration& clientConfiguration = Aws::Inspector::InspectorClientConfiguration());
 
  /* Legacy constructors due deprecation */
  InspectorClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  InspectorClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  InspectorClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~InspectorClient();
 
  virtual Model::AddAttributesToFindingsOutcome AddAttributesToFindings(const Model::AddAttributesToFindingsRequest& request) const;
 
  template <typename AddAttributesToFindingsRequestT = Model::AddAttributesToFindingsRequest>
  Model::AddAttributesToFindingsOutcomeCallable AddAttributesToFindingsCallable(const AddAttributesToFindingsRequestT& request) const {
    return SubmitCallable(&InspectorClient::AddAttributesToFindings, request);
  }
 
  template <typename AddAttributesToFindingsRequestT = Model::AddAttributesToFindingsRequest>
  void AddAttributesToFindingsAsync(const AddAttributesToFindingsRequestT& request,
                                    const AddAttributesToFindingsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::AddAttributesToFindings, request, handler, context);
  }
 
  virtual Model::CreateAssessmentTargetOutcome CreateAssessmentTarget(const Model::CreateAssessmentTargetRequest& request) const;
 
  template <typename CreateAssessmentTargetRequestT = Model::CreateAssessmentTargetRequest>
  Model::CreateAssessmentTargetOutcomeCallable CreateAssessmentTargetCallable(const CreateAssessmentTargetRequestT& request) const {
    return SubmitCallable(&InspectorClient::CreateAssessmentTarget, request);
  }
 
  template <typename CreateAssessmentTargetRequestT = Model::CreateAssessmentTargetRequest>
  void CreateAssessmentTargetAsync(const CreateAssessmentTargetRequestT& request,
                                   const CreateAssessmentTargetResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::CreateAssessmentTarget, request, handler, context);
  }
 
  virtual Model::CreateAssessmentTemplateOutcome CreateAssessmentTemplate(const Model::CreateAssessmentTemplateRequest& request) const;
 
  template <typename CreateAssessmentTemplateRequestT = Model::CreateAssessmentTemplateRequest>
  Model::CreateAssessmentTemplateOutcomeCallable CreateAssessmentTemplateCallable(const CreateAssessmentTemplateRequestT& request) const {
    return SubmitCallable(&InspectorClient::CreateAssessmentTemplate, request);
  }
 
  template <typename CreateAssessmentTemplateRequestT = Model::CreateAssessmentTemplateRequest>
  void CreateAssessmentTemplateAsync(const CreateAssessmentTemplateRequestT& request,
                                     const CreateAssessmentTemplateResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::CreateAssessmentTemplate, request, handler, context);
  }
 
  virtual Model::CreateExclusionsPreviewOutcome CreateExclusionsPreview(const Model::CreateExclusionsPreviewRequest& request) const;
 
  template <typename CreateExclusionsPreviewRequestT = Model::CreateExclusionsPreviewRequest>
  Model::CreateExclusionsPreviewOutcomeCallable CreateExclusionsPreviewCallable(const CreateExclusionsPreviewRequestT& request) const {
    return SubmitCallable(&InspectorClient::CreateExclusionsPreview, request);
  }
 
  template <typename CreateExclusionsPreviewRequestT = Model::CreateExclusionsPreviewRequest>
  void CreateExclusionsPreviewAsync(const CreateExclusionsPreviewRequestT& request,
                                    const CreateExclusionsPreviewResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::CreateExclusionsPreview, request, handler, context);
  }
 
  virtual Model::CreateResourceGroupOutcome CreateResourceGroup(const Model::CreateResourceGroupRequest& request) const;
 
  template <typename CreateResourceGroupRequestT = Model::CreateResourceGroupRequest>
  Model::CreateResourceGroupOutcomeCallable CreateResourceGroupCallable(const CreateResourceGroupRequestT& request) const {
    return SubmitCallable(&InspectorClient::CreateResourceGroup, request);
  }
 
  template <typename CreateResourceGroupRequestT = Model::CreateResourceGroupRequest>
  void CreateResourceGroupAsync(const CreateResourceGroupRequestT& request, const CreateResourceGroupResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::CreateResourceGroup, request, handler, context);
  }
 
  virtual Model::DeleteAssessmentRunOutcome DeleteAssessmentRun(const Model::DeleteAssessmentRunRequest& request) const;
 
  template <typename DeleteAssessmentRunRequestT = Model::DeleteAssessmentRunRequest>
  Model::DeleteAssessmentRunOutcomeCallable DeleteAssessmentRunCallable(const DeleteAssessmentRunRequestT& request) const {
    return SubmitCallable(&InspectorClient::DeleteAssessmentRun, request);
  }
 
  template <typename DeleteAssessmentRunRequestT = Model::DeleteAssessmentRunRequest>
  void DeleteAssessmentRunAsync(const DeleteAssessmentRunRequestT& request, const DeleteAssessmentRunResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::DeleteAssessmentRun, request, handler, context);
  }
 
  virtual Model::DeleteAssessmentTargetOutcome DeleteAssessmentTarget(const Model::DeleteAssessmentTargetRequest& request) const;
 
  template <typename DeleteAssessmentTargetRequestT = Model::DeleteAssessmentTargetRequest>
  Model::DeleteAssessmentTargetOutcomeCallable DeleteAssessmentTargetCallable(const DeleteAssessmentTargetRequestT& request) const {
    return SubmitCallable(&InspectorClient::DeleteAssessmentTarget, request);
  }
 
  template <typename DeleteAssessmentTargetRequestT = Model::DeleteAssessmentTargetRequest>
  void DeleteAssessmentTargetAsync(const DeleteAssessmentTargetRequestT& request,
                                   const DeleteAssessmentTargetResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::DeleteAssessmentTarget, request, handler, context);
  }
 
  virtual Model::DeleteAssessmentTemplateOutcome DeleteAssessmentTemplate(const Model::DeleteAssessmentTemplateRequest& request) const;
 
  template <typename DeleteAssessmentTemplateRequestT = Model::DeleteAssessmentTemplateRequest>
  Model::DeleteAssessmentTemplateOutcomeCallable DeleteAssessmentTemplateCallable(const DeleteAssessmentTemplateRequestT& request) const {
    return SubmitCallable(&InspectorClient::DeleteAssessmentTemplate, request);
  }
 
  template <typename DeleteAssessmentTemplateRequestT = Model::DeleteAssessmentTemplateRequest>
  void DeleteAssessmentTemplateAsync(const DeleteAssessmentTemplateRequestT& request,
                                     const DeleteAssessmentTemplateResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::DeleteAssessmentTemplate, request, handler, context);
  }
 
  virtual Model::DescribeAssessmentRunsOutcome DescribeAssessmentRuns(const Model::DescribeAssessmentRunsRequest& request) const;
 
  template <typename DescribeAssessmentRunsRequestT = Model::DescribeAssessmentRunsRequest>
  Model::DescribeAssessmentRunsOutcomeCallable DescribeAssessmentRunsCallable(const DescribeAssessmentRunsRequestT& request) const {
    return SubmitCallable(&InspectorClient::DescribeAssessmentRuns, request);
  }
 
  template <typename DescribeAssessmentRunsRequestT = Model::DescribeAssessmentRunsRequest>
  void DescribeAssessmentRunsAsync(const DescribeAssessmentRunsRequestT& request,
                                   const DescribeAssessmentRunsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::DescribeAssessmentRuns, request, handler, context);
  }
 
  virtual Model::DescribeAssessmentTargetsOutcome DescribeAssessmentTargets(const Model::DescribeAssessmentTargetsRequest& request) const;
 
  template <typename DescribeAssessmentTargetsRequestT = Model::DescribeAssessmentTargetsRequest>
  Model::DescribeAssessmentTargetsOutcomeCallable DescribeAssessmentTargetsCallable(
      const DescribeAssessmentTargetsRequestT& request) const {
    return SubmitCallable(&InspectorClient::DescribeAssessmentTargets, request);
  }
 
  template <typename DescribeAssessmentTargetsRequestT = Model::DescribeAssessmentTargetsRequest>
  void DescribeAssessmentTargetsAsync(const DescribeAssessmentTargetsRequestT& request,
                                      const DescribeAssessmentTargetsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::DescribeAssessmentTargets, request, handler, context);
  }
 
  virtual Model::DescribeAssessmentTemplatesOutcome DescribeAssessmentTemplates(
      const Model::DescribeAssessmentTemplatesRequest& request) const;
 
  template <typename DescribeAssessmentTemplatesRequestT = Model::DescribeAssessmentTemplatesRequest>
  Model::DescribeAssessmentTemplatesOutcomeCallable DescribeAssessmentTemplatesCallable(
      const DescribeAssessmentTemplatesRequestT& request) const {
    return SubmitCallable(&InspectorClient::DescribeAssessmentTemplates, request);
  }
 
  template <typename DescribeAssessmentTemplatesRequestT = Model::DescribeAssessmentTemplatesRequest>
  void DescribeAssessmentTemplatesAsync(const DescribeAssessmentTemplatesRequestT& request,
                                        const DescribeAssessmentTemplatesResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::DescribeAssessmentTemplates, request, handler, context);
  }
 
  virtual Model::DescribeCrossAccountAccessRoleOutcome DescribeCrossAccountAccessRole(
      const Model::DescribeCrossAccountAccessRoleRequest& request = {}) const;
 
  template <typename DescribeCrossAccountAccessRoleRequestT = Model::DescribeCrossAccountAccessRoleRequest>
  Model::DescribeCrossAccountAccessRoleOutcomeCallable DescribeCrossAccountAccessRoleCallable(
      const DescribeCrossAccountAccessRoleRequestT& request = {}) const {
    return SubmitCallable(&InspectorClient::DescribeCrossAccountAccessRole, request);
  }
 
  template <typename DescribeCrossAccountAccessRoleRequestT = Model::DescribeCrossAccountAccessRoleRequest>
  void DescribeCrossAccountAccessRoleAsync(const DescribeCrossAccountAccessRoleResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const DescribeCrossAccountAccessRoleRequestT& request = {}) const {
    return SubmitAsync(&InspectorClient::DescribeCrossAccountAccessRole, request, handler, context);
  }
 
  virtual Model::DescribeExclusionsOutcome DescribeExclusions(const Model::DescribeExclusionsRequest& request) const;
 
  template <typename DescribeExclusionsRequestT = Model::DescribeExclusionsRequest>
  Model::DescribeExclusionsOutcomeCallable DescribeExclusionsCallable(const DescribeExclusionsRequestT& request) const {
    return SubmitCallable(&InspectorClient::DescribeExclusions, request);
  }
 
  template <typename DescribeExclusionsRequestT = Model::DescribeExclusionsRequest>
  void DescribeExclusionsAsync(const DescribeExclusionsRequestT& request, const DescribeExclusionsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::DescribeExclusions, request, handler, context);
  }
 
  virtual Model::DescribeFindingsOutcome DescribeFindings(const Model::DescribeFindingsRequest& request) const;
 
  template <typename DescribeFindingsRequestT = Model::DescribeFindingsRequest>
  Model::DescribeFindingsOutcomeCallable DescribeFindingsCallable(const DescribeFindingsRequestT& request) const {
    return SubmitCallable(&InspectorClient::DescribeFindings, request);
  }
 
  template <typename DescribeFindingsRequestT = Model::DescribeFindingsRequest>
  void DescribeFindingsAsync(const DescribeFindingsRequestT& request, const DescribeFindingsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::DescribeFindings, request, handler, context);
  }
 
  virtual Model::DescribeResourceGroupsOutcome DescribeResourceGroups(const Model::DescribeResourceGroupsRequest& request) const;
 
  template <typename DescribeResourceGroupsRequestT = Model::DescribeResourceGroupsRequest>
  Model::DescribeResourceGroupsOutcomeCallable DescribeResourceGroupsCallable(const DescribeResourceGroupsRequestT& request) const {
    return SubmitCallable(&InspectorClient::DescribeResourceGroups, request);
  }
 
  template <typename DescribeResourceGroupsRequestT = Model::DescribeResourceGroupsRequest>
  void DescribeResourceGroupsAsync(const DescribeResourceGroupsRequestT& request,
                                   const DescribeResourceGroupsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::DescribeResourceGroups, request, handler, context);
  }
 
  virtual Model::DescribeRulesPackagesOutcome DescribeRulesPackages(const Model::DescribeRulesPackagesRequest& request) const;
 
  template <typename DescribeRulesPackagesRequestT = Model::DescribeRulesPackagesRequest>
  Model::DescribeRulesPackagesOutcomeCallable DescribeRulesPackagesCallable(const DescribeRulesPackagesRequestT& request) const {
    return SubmitCallable(&InspectorClient::DescribeRulesPackages, request);
  }
 
  template <typename DescribeRulesPackagesRequestT = Model::DescribeRulesPackagesRequest>
  void DescribeRulesPackagesAsync(const DescribeRulesPackagesRequestT& request, const DescribeRulesPackagesResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::DescribeRulesPackages, request, handler, context);
  }
 
  virtual Model::GetAssessmentReportOutcome GetAssessmentReport(const Model::GetAssessmentReportRequest& request) const;
 
  template <typename GetAssessmentReportRequestT = Model::GetAssessmentReportRequest>
  Model::GetAssessmentReportOutcomeCallable GetAssessmentReportCallable(const GetAssessmentReportRequestT& request) const {
    return SubmitCallable(&InspectorClient::GetAssessmentReport, request);
  }
 
  template <typename GetAssessmentReportRequestT = Model::GetAssessmentReportRequest>
  void GetAssessmentReportAsync(const GetAssessmentReportRequestT& request, const GetAssessmentReportResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::GetAssessmentReport, request, handler, context);
  }
 
  virtual Model::GetExclusionsPreviewOutcome GetExclusionsPreview(const Model::GetExclusionsPreviewRequest& request) const;
 
  template <typename GetExclusionsPreviewRequestT = Model::GetExclusionsPreviewRequest>
  Model::GetExclusionsPreviewOutcomeCallable GetExclusionsPreviewCallable(const GetExclusionsPreviewRequestT& request) const {
    return SubmitCallable(&InspectorClient::GetExclusionsPreview, request);
  }
 
  template <typename GetExclusionsPreviewRequestT = Model::GetExclusionsPreviewRequest>
  void GetExclusionsPreviewAsync(const GetExclusionsPreviewRequestT& request, const GetExclusionsPreviewResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::GetExclusionsPreview, request, handler, context);
  }
 
  virtual Model::GetTelemetryMetadataOutcome GetTelemetryMetadata(const Model::GetTelemetryMetadataRequest& request) const;
 
  template <typename GetTelemetryMetadataRequestT = Model::GetTelemetryMetadataRequest>
  Model::GetTelemetryMetadataOutcomeCallable GetTelemetryMetadataCallable(const GetTelemetryMetadataRequestT& request) const {
    return SubmitCallable(&InspectorClient::GetTelemetryMetadata, request);
  }
 
  template <typename GetTelemetryMetadataRequestT = Model::GetTelemetryMetadataRequest>
  void GetTelemetryMetadataAsync(const GetTelemetryMetadataRequestT& request, const GetTelemetryMetadataResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::GetTelemetryMetadata, request, handler, context);
  }
 
  virtual Model::ListAssessmentRunAgentsOutcome ListAssessmentRunAgents(const Model::ListAssessmentRunAgentsRequest& request) const;
 
  template <typename ListAssessmentRunAgentsRequestT = Model::ListAssessmentRunAgentsRequest>
  Model::ListAssessmentRunAgentsOutcomeCallable ListAssessmentRunAgentsCallable(const ListAssessmentRunAgentsRequestT& request) const {
    return SubmitCallable(&InspectorClient::ListAssessmentRunAgents, request);
  }
 
  template <typename ListAssessmentRunAgentsRequestT = Model::ListAssessmentRunAgentsRequest>
  void ListAssessmentRunAgentsAsync(const ListAssessmentRunAgentsRequestT& request,
                                    const ListAssessmentRunAgentsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::ListAssessmentRunAgents, request, handler, context);
  }
 
  virtual Model::ListAssessmentRunsOutcome ListAssessmentRuns(const Model::ListAssessmentRunsRequest& request = {}) const;
 
  template <typename ListAssessmentRunsRequestT = Model::ListAssessmentRunsRequest>
  Model::ListAssessmentRunsOutcomeCallable ListAssessmentRunsCallable(const ListAssessmentRunsRequestT& request = {}) const {
    return SubmitCallable(&InspectorClient::ListAssessmentRuns, request);
  }
 
  template <typename ListAssessmentRunsRequestT = Model::ListAssessmentRunsRequest>
  void ListAssessmentRunsAsync(const ListAssessmentRunsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListAssessmentRunsRequestT& request = {}) const {
    return SubmitAsync(&InspectorClient::ListAssessmentRuns, request, handler, context);
  }
 
  virtual Model::ListAssessmentTargetsOutcome ListAssessmentTargets(const Model::ListAssessmentTargetsRequest& request = {}) const;
 
  template <typename ListAssessmentTargetsRequestT = Model::ListAssessmentTargetsRequest>
  Model::ListAssessmentTargetsOutcomeCallable ListAssessmentTargetsCallable(const ListAssessmentTargetsRequestT& request = {}) const {
    return SubmitCallable(&InspectorClient::ListAssessmentTargets, request);
  }
 
  template <typename ListAssessmentTargetsRequestT = Model::ListAssessmentTargetsRequest>
  void ListAssessmentTargetsAsync(const ListAssessmentTargetsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const ListAssessmentTargetsRequestT& request = {}) const {
    return SubmitAsync(&InspectorClient::ListAssessmentTargets, request, handler, context);
  }
 
  virtual Model::ListAssessmentTemplatesOutcome ListAssessmentTemplates(const Model::ListAssessmentTemplatesRequest& request = {}) const;
 
  template <typename ListAssessmentTemplatesRequestT = Model::ListAssessmentTemplatesRequest>
  Model::ListAssessmentTemplatesOutcomeCallable ListAssessmentTemplatesCallable(const ListAssessmentTemplatesRequestT& request = {}) const {
    return SubmitCallable(&InspectorClient::ListAssessmentTemplates, request);
  }
 
  template <typename ListAssessmentTemplatesRequestT = Model::ListAssessmentTemplatesRequest>
  void ListAssessmentTemplatesAsync(const ListAssessmentTemplatesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListAssessmentTemplatesRequestT& request = {}) const {
    return SubmitAsync(&InspectorClient::ListAssessmentTemplates, request, handler, context);
  }
 
  virtual Model::ListEventSubscriptionsOutcome ListEventSubscriptions(const Model::ListEventSubscriptionsRequest& request = {}) const;
 
  template <typename ListEventSubscriptionsRequestT = Model::ListEventSubscriptionsRequest>
  Model::ListEventSubscriptionsOutcomeCallable ListEventSubscriptionsCallable(const ListEventSubscriptionsRequestT& request = {}) const {
    return SubmitCallable(&InspectorClient::ListEventSubscriptions, request);
  }
 
  template <typename ListEventSubscriptionsRequestT = Model::ListEventSubscriptionsRequest>
  void ListEventSubscriptionsAsync(const ListEventSubscriptionsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListEventSubscriptionsRequestT& request = {}) const {
    return SubmitAsync(&InspectorClient::ListEventSubscriptions, request, handler, context);
  }
 
  virtual Model::ListExclusionsOutcome ListExclusions(const Model::ListExclusionsRequest& request) const;
 
  template <typename ListExclusionsRequestT = Model::ListExclusionsRequest>
  Model::ListExclusionsOutcomeCallable ListExclusionsCallable(const ListExclusionsRequestT& request) const {
    return SubmitCallable(&InspectorClient::ListExclusions, request);
  }
 
  template <typename ListExclusionsRequestT = Model::ListExclusionsRequest>
  void ListExclusionsAsync(const ListExclusionsRequestT& request, const ListExclusionsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::ListExclusions, 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(&InspectorClient::ListFindings, request);
  }
 
  template <typename ListFindingsRequestT = Model::ListFindingsRequest>
  void ListFindingsAsync(const ListFindingsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListFindingsRequestT& request = {}) const {
    return SubmitAsync(&InspectorClient::ListFindings, request, handler, context);
  }
 
  virtual Model::ListRulesPackagesOutcome ListRulesPackages(const Model::ListRulesPackagesRequest& request = {}) const;
 
  template <typename ListRulesPackagesRequestT = Model::ListRulesPackagesRequest>
  Model::ListRulesPackagesOutcomeCallable ListRulesPackagesCallable(const ListRulesPackagesRequestT& request = {}) const {
    return SubmitCallable(&InspectorClient::ListRulesPackages, request);
  }
 
  template <typename ListRulesPackagesRequestT = Model::ListRulesPackagesRequest>
  void ListRulesPackagesAsync(const ListRulesPackagesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListRulesPackagesRequestT& request = {}) const {
    return SubmitAsync(&InspectorClient::ListRulesPackages, 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(&InspectorClient::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(&InspectorClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::PreviewAgentsOutcome PreviewAgents(const Model::PreviewAgentsRequest& request) const;
 
  template <typename PreviewAgentsRequestT = Model::PreviewAgentsRequest>
  Model::PreviewAgentsOutcomeCallable PreviewAgentsCallable(const PreviewAgentsRequestT& request) const {
    return SubmitCallable(&InspectorClient::PreviewAgents, request);
  }
 
  template <typename PreviewAgentsRequestT = Model::PreviewAgentsRequest>
  void PreviewAgentsAsync(const PreviewAgentsRequestT& request, const PreviewAgentsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::PreviewAgents, request, handler, context);
  }
 
  virtual Model::RegisterCrossAccountAccessRoleOutcome RegisterCrossAccountAccessRole(
      const Model::RegisterCrossAccountAccessRoleRequest& request) const;
 
  template <typename RegisterCrossAccountAccessRoleRequestT = Model::RegisterCrossAccountAccessRoleRequest>
  Model::RegisterCrossAccountAccessRoleOutcomeCallable RegisterCrossAccountAccessRoleCallable(
      const RegisterCrossAccountAccessRoleRequestT& request) const {
    return SubmitCallable(&InspectorClient::RegisterCrossAccountAccessRole, request);
  }
 
  template <typename RegisterCrossAccountAccessRoleRequestT = Model::RegisterCrossAccountAccessRoleRequest>
  void RegisterCrossAccountAccessRoleAsync(const RegisterCrossAccountAccessRoleRequestT& request,
                                           const RegisterCrossAccountAccessRoleResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::RegisterCrossAccountAccessRole, request, handler, context);
  }
 
  virtual Model::RemoveAttributesFromFindingsOutcome RemoveAttributesFromFindings(
      const Model::RemoveAttributesFromFindingsRequest& request) const;
 
  template <typename RemoveAttributesFromFindingsRequestT = Model::RemoveAttributesFromFindingsRequest>
  Model::RemoveAttributesFromFindingsOutcomeCallable RemoveAttributesFromFindingsCallable(
      const RemoveAttributesFromFindingsRequestT& request) const {
    return SubmitCallable(&InspectorClient::RemoveAttributesFromFindings, request);
  }
 
  template <typename RemoveAttributesFromFindingsRequestT = Model::RemoveAttributesFromFindingsRequest>
  void RemoveAttributesFromFindingsAsync(const RemoveAttributesFromFindingsRequestT& request,
                                         const RemoveAttributesFromFindingsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::RemoveAttributesFromFindings, request, handler, context);
  }
 
  virtual Model::SetTagsForResourceOutcome SetTagsForResource(const Model::SetTagsForResourceRequest& request) const;
 
  template <typename SetTagsForResourceRequestT = Model::SetTagsForResourceRequest>
  Model::SetTagsForResourceOutcomeCallable SetTagsForResourceCallable(const SetTagsForResourceRequestT& request) const {
    return SubmitCallable(&InspectorClient::SetTagsForResource, request);
  }
 
  template <typename SetTagsForResourceRequestT = Model::SetTagsForResourceRequest>
  void SetTagsForResourceAsync(const SetTagsForResourceRequestT& request, const SetTagsForResourceResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::SetTagsForResource, request, handler, context);
  }
 
  virtual Model::StartAssessmentRunOutcome StartAssessmentRun(const Model::StartAssessmentRunRequest& request) const;
 
  template <typename StartAssessmentRunRequestT = Model::StartAssessmentRunRequest>
  Model::StartAssessmentRunOutcomeCallable StartAssessmentRunCallable(const StartAssessmentRunRequestT& request) const {
    return SubmitCallable(&InspectorClient::StartAssessmentRun, request);
  }
 
  template <typename StartAssessmentRunRequestT = Model::StartAssessmentRunRequest>
  void StartAssessmentRunAsync(const StartAssessmentRunRequestT& request, const StartAssessmentRunResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::StartAssessmentRun, request, handler, context);
  }
 
  virtual Model::StopAssessmentRunOutcome StopAssessmentRun(const Model::StopAssessmentRunRequest& request) const;
 
  template <typename StopAssessmentRunRequestT = Model::StopAssessmentRunRequest>
  Model::StopAssessmentRunOutcomeCallable StopAssessmentRunCallable(const StopAssessmentRunRequestT& request) const {
    return SubmitCallable(&InspectorClient::StopAssessmentRun, request);
  }
 
  template <typename StopAssessmentRunRequestT = Model::StopAssessmentRunRequest>
  void StopAssessmentRunAsync(const StopAssessmentRunRequestT& request, const StopAssessmentRunResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::StopAssessmentRun, request, handler, context);
  }
 
  virtual Model::SubscribeToEventOutcome SubscribeToEvent(const Model::SubscribeToEventRequest& request) const;
 
  template <typename SubscribeToEventRequestT = Model::SubscribeToEventRequest>
  Model::SubscribeToEventOutcomeCallable SubscribeToEventCallable(const SubscribeToEventRequestT& request) const {
    return SubmitCallable(&InspectorClient::SubscribeToEvent, request);
  }
 
  template <typename SubscribeToEventRequestT = Model::SubscribeToEventRequest>
  void SubscribeToEventAsync(const SubscribeToEventRequestT& request, const SubscribeToEventResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::SubscribeToEvent, request, handler, context);
  }
 
  virtual Model::UnsubscribeFromEventOutcome UnsubscribeFromEvent(const Model::UnsubscribeFromEventRequest& request) const;
 
  template <typename UnsubscribeFromEventRequestT = Model::UnsubscribeFromEventRequest>
  Model::UnsubscribeFromEventOutcomeCallable UnsubscribeFromEventCallable(const UnsubscribeFromEventRequestT& request) const {
    return SubmitCallable(&InspectorClient::UnsubscribeFromEvent, request);
  }
 
  template <typename UnsubscribeFromEventRequestT = Model::UnsubscribeFromEventRequest>
  void UnsubscribeFromEventAsync(const UnsubscribeFromEventRequestT& request, const UnsubscribeFromEventResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::UnsubscribeFromEvent, request, handler, context);
  }
 
  virtual Model::UpdateAssessmentTargetOutcome UpdateAssessmentTarget(const Model::UpdateAssessmentTargetRequest& request) const;
 
  template <typename UpdateAssessmentTargetRequestT = Model::UpdateAssessmentTargetRequest>
  Model::UpdateAssessmentTargetOutcomeCallable UpdateAssessmentTargetCallable(const UpdateAssessmentTargetRequestT& request) const {
    return SubmitCallable(&InspectorClient::UpdateAssessmentTarget, request);
  }
 
  template <typename UpdateAssessmentTargetRequestT = Model::UpdateAssessmentTargetRequest>
  void UpdateAssessmentTargetAsync(const UpdateAssessmentTargetRequestT& request,
                                   const UpdateAssessmentTargetResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InspectorClient::UpdateAssessmentTarget, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<InspectorEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<InspectorClient>;
  void init(const InspectorClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, InspectorError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  InspectorClientConfiguration m_clientConfiguration;
  std::shared_ptr<InspectorEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Inspector
}  // namespace Aws