InspectorClient.h

 
#pragma once
#include <aws/inspector/Inspector_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/inspector/InspectorServiceClientModel.h>
 
namespace Aws
{
namespace Inspector
{
  class AWS_INSPECTOR_API InspectorClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<InspectorEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<InspectorClient>;
      void init(const InspectorClientConfiguration& clientConfiguration);
 
      InspectorClientConfiguration m_clientConfiguration;
      std::shared_ptr<InspectorEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Inspector
} // namespace Aws