AccessAnalyzerClient.h

 
#pragma once
#include <aws/accessanalyzer/AccessAnalyzer_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/accessanalyzer/AccessAnalyzerServiceClientModel.h>
 
namespace Aws
{
namespace AccessAnalyzer
{
  class AWS_ACCESSANALYZER_API AccessAnalyzerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<AccessAnalyzerClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef AccessAnalyzerClientConfiguration ClientConfigurationType;
      typedef AccessAnalyzerEndpointProvider EndpointProviderType;
 
        AccessAnalyzerClient(const Aws::AccessAnalyzer::AccessAnalyzerClientConfiguration& clientConfiguration = Aws::AccessAnalyzer::AccessAnalyzerClientConfiguration(),
                             std::shared_ptr<AccessAnalyzerEndpointProviderBase> endpointProvider = nullptr);
 
        AccessAnalyzerClient(const Aws::Auth::AWSCredentials& credentials,
                             std::shared_ptr<AccessAnalyzerEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::AccessAnalyzer::AccessAnalyzerClientConfiguration& clientConfiguration = Aws::AccessAnalyzer::AccessAnalyzerClientConfiguration());
 
        AccessAnalyzerClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             std::shared_ptr<AccessAnalyzerEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::AccessAnalyzer::AccessAnalyzerClientConfiguration& clientConfiguration = Aws::AccessAnalyzer::AccessAnalyzerClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        AccessAnalyzerClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        AccessAnalyzerClient(const Aws::Auth::AWSCredentials& credentials,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
        AccessAnalyzerClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~AccessAnalyzerClient();
 
        virtual Model::ApplyArchiveRuleOutcome ApplyArchiveRule(const Model::ApplyArchiveRuleRequest& request) const;
 
        template<typename ApplyArchiveRuleRequestT = Model::ApplyArchiveRuleRequest>
        Model::ApplyArchiveRuleOutcomeCallable ApplyArchiveRuleCallable(const ApplyArchiveRuleRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::ApplyArchiveRule, request);
        }
 
        template<typename ApplyArchiveRuleRequestT = Model::ApplyArchiveRuleRequest>
        void ApplyArchiveRuleAsync(const ApplyArchiveRuleRequestT& request, const ApplyArchiveRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::ApplyArchiveRule, request, handler, context);
        }
 
        virtual Model::CancelPolicyGenerationOutcome CancelPolicyGeneration(const Model::CancelPolicyGenerationRequest& request) const;
 
        template<typename CancelPolicyGenerationRequestT = Model::CancelPolicyGenerationRequest>
        Model::CancelPolicyGenerationOutcomeCallable CancelPolicyGenerationCallable(const CancelPolicyGenerationRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::CancelPolicyGeneration, request);
        }
 
        template<typename CancelPolicyGenerationRequestT = Model::CancelPolicyGenerationRequest>
        void CancelPolicyGenerationAsync(const CancelPolicyGenerationRequestT& request, const CancelPolicyGenerationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::CancelPolicyGeneration, request, handler, context);
        }
 
        virtual Model::CheckAccessNotGrantedOutcome CheckAccessNotGranted(const Model::CheckAccessNotGrantedRequest& request) const;
 
        template<typename CheckAccessNotGrantedRequestT = Model::CheckAccessNotGrantedRequest>
        Model::CheckAccessNotGrantedOutcomeCallable CheckAccessNotGrantedCallable(const CheckAccessNotGrantedRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::CheckAccessNotGranted, request);
        }
 
        template<typename CheckAccessNotGrantedRequestT = Model::CheckAccessNotGrantedRequest>
        void CheckAccessNotGrantedAsync(const CheckAccessNotGrantedRequestT& request, const CheckAccessNotGrantedResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::CheckAccessNotGranted, request, handler, context);
        }
 
        virtual Model::CheckNoNewAccessOutcome CheckNoNewAccess(const Model::CheckNoNewAccessRequest& request) const;
 
        template<typename CheckNoNewAccessRequestT = Model::CheckNoNewAccessRequest>
        Model::CheckNoNewAccessOutcomeCallable CheckNoNewAccessCallable(const CheckNoNewAccessRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::CheckNoNewAccess, request);
        }
 
        template<typename CheckNoNewAccessRequestT = Model::CheckNoNewAccessRequest>
        void CheckNoNewAccessAsync(const CheckNoNewAccessRequestT& request, const CheckNoNewAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::CheckNoNewAccess, request, handler, context);
        }
 
        virtual Model::CheckNoPublicAccessOutcome CheckNoPublicAccess(const Model::CheckNoPublicAccessRequest& request) const;
 
        template<typename CheckNoPublicAccessRequestT = Model::CheckNoPublicAccessRequest>
        Model::CheckNoPublicAccessOutcomeCallable CheckNoPublicAccessCallable(const CheckNoPublicAccessRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::CheckNoPublicAccess, request);
        }
 
        template<typename CheckNoPublicAccessRequestT = Model::CheckNoPublicAccessRequest>
        void CheckNoPublicAccessAsync(const CheckNoPublicAccessRequestT& request, const CheckNoPublicAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::CheckNoPublicAccess, request, handler, context);
        }
 
        virtual Model::CreateAccessPreviewOutcome CreateAccessPreview(const Model::CreateAccessPreviewRequest& request) const;
 
        template<typename CreateAccessPreviewRequestT = Model::CreateAccessPreviewRequest>
        Model::CreateAccessPreviewOutcomeCallable CreateAccessPreviewCallable(const CreateAccessPreviewRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::CreateAccessPreview, request);
        }
 
        template<typename CreateAccessPreviewRequestT = Model::CreateAccessPreviewRequest>
        void CreateAccessPreviewAsync(const CreateAccessPreviewRequestT& request, const CreateAccessPreviewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::CreateAccessPreview, request, handler, context);
        }
 
        virtual Model::CreateAnalyzerOutcome CreateAnalyzer(const Model::CreateAnalyzerRequest& request) const;
 
        template<typename CreateAnalyzerRequestT = Model::CreateAnalyzerRequest>
        Model::CreateAnalyzerOutcomeCallable CreateAnalyzerCallable(const CreateAnalyzerRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::CreateAnalyzer, request);
        }
 
        template<typename CreateAnalyzerRequestT = Model::CreateAnalyzerRequest>
        void CreateAnalyzerAsync(const CreateAnalyzerRequestT& request, const CreateAnalyzerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::CreateAnalyzer, request, handler, context);
        }
 
        virtual Model::CreateArchiveRuleOutcome CreateArchiveRule(const Model::CreateArchiveRuleRequest& request) const;
 
        template<typename CreateArchiveRuleRequestT = Model::CreateArchiveRuleRequest>
        Model::CreateArchiveRuleOutcomeCallable CreateArchiveRuleCallable(const CreateArchiveRuleRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::CreateArchiveRule, request);
        }
 
        template<typename CreateArchiveRuleRequestT = Model::CreateArchiveRuleRequest>
        void CreateArchiveRuleAsync(const CreateArchiveRuleRequestT& request, const CreateArchiveRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::CreateArchiveRule, request, handler, context);
        }
 
        virtual Model::DeleteAnalyzerOutcome DeleteAnalyzer(const Model::DeleteAnalyzerRequest& request) const;
 
        template<typename DeleteAnalyzerRequestT = Model::DeleteAnalyzerRequest>
        Model::DeleteAnalyzerOutcomeCallable DeleteAnalyzerCallable(const DeleteAnalyzerRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::DeleteAnalyzer, request);
        }
 
        template<typename DeleteAnalyzerRequestT = Model::DeleteAnalyzerRequest>
        void DeleteAnalyzerAsync(const DeleteAnalyzerRequestT& request, const DeleteAnalyzerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::DeleteAnalyzer, request, handler, context);
        }
 
        virtual Model::DeleteArchiveRuleOutcome DeleteArchiveRule(const Model::DeleteArchiveRuleRequest& request) const;
 
        template<typename DeleteArchiveRuleRequestT = Model::DeleteArchiveRuleRequest>
        Model::DeleteArchiveRuleOutcomeCallable DeleteArchiveRuleCallable(const DeleteArchiveRuleRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::DeleteArchiveRule, request);
        }
 
        template<typename DeleteArchiveRuleRequestT = Model::DeleteArchiveRuleRequest>
        void DeleteArchiveRuleAsync(const DeleteArchiveRuleRequestT& request, const DeleteArchiveRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::DeleteArchiveRule, request, handler, context);
        }
 
        virtual Model::GenerateFindingRecommendationOutcome GenerateFindingRecommendation(const Model::GenerateFindingRecommendationRequest& request) const;
 
        template<typename GenerateFindingRecommendationRequestT = Model::GenerateFindingRecommendationRequest>
        Model::GenerateFindingRecommendationOutcomeCallable GenerateFindingRecommendationCallable(const GenerateFindingRecommendationRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::GenerateFindingRecommendation, request);
        }
 
        template<typename GenerateFindingRecommendationRequestT = Model::GenerateFindingRecommendationRequest>
        void GenerateFindingRecommendationAsync(const GenerateFindingRecommendationRequestT& request, const GenerateFindingRecommendationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::GenerateFindingRecommendation, request, handler, context);
        }
 
        virtual Model::GetAccessPreviewOutcome GetAccessPreview(const Model::GetAccessPreviewRequest& request) const;
 
        template<typename GetAccessPreviewRequestT = Model::GetAccessPreviewRequest>
        Model::GetAccessPreviewOutcomeCallable GetAccessPreviewCallable(const GetAccessPreviewRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::GetAccessPreview, request);
        }
 
        template<typename GetAccessPreviewRequestT = Model::GetAccessPreviewRequest>
        void GetAccessPreviewAsync(const GetAccessPreviewRequestT& request, const GetAccessPreviewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::GetAccessPreview, request, handler, context);
        }
 
        virtual Model::GetAnalyzedResourceOutcome GetAnalyzedResource(const Model::GetAnalyzedResourceRequest& request) const;
 
        template<typename GetAnalyzedResourceRequestT = Model::GetAnalyzedResourceRequest>
        Model::GetAnalyzedResourceOutcomeCallable GetAnalyzedResourceCallable(const GetAnalyzedResourceRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::GetAnalyzedResource, request);
        }
 
        template<typename GetAnalyzedResourceRequestT = Model::GetAnalyzedResourceRequest>
        void GetAnalyzedResourceAsync(const GetAnalyzedResourceRequestT& request, const GetAnalyzedResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::GetAnalyzedResource, request, handler, context);
        }
 
        virtual Model::GetAnalyzerOutcome GetAnalyzer(const Model::GetAnalyzerRequest& request) const;
 
        template<typename GetAnalyzerRequestT = Model::GetAnalyzerRequest>
        Model::GetAnalyzerOutcomeCallable GetAnalyzerCallable(const GetAnalyzerRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::GetAnalyzer, request);
        }
 
        template<typename GetAnalyzerRequestT = Model::GetAnalyzerRequest>
        void GetAnalyzerAsync(const GetAnalyzerRequestT& request, const GetAnalyzerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::GetAnalyzer, request, handler, context);
        }
 
        virtual Model::GetArchiveRuleOutcome GetArchiveRule(const Model::GetArchiveRuleRequest& request) const;
 
        template<typename GetArchiveRuleRequestT = Model::GetArchiveRuleRequest>
        Model::GetArchiveRuleOutcomeCallable GetArchiveRuleCallable(const GetArchiveRuleRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::GetArchiveRule, request);
        }
 
        template<typename GetArchiveRuleRequestT = Model::GetArchiveRuleRequest>
        void GetArchiveRuleAsync(const GetArchiveRuleRequestT& request, const GetArchiveRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::GetArchiveRule, request, handler, context);
        }
 
        virtual Model::GetFindingOutcome GetFinding(const Model::GetFindingRequest& request) const;
 
        template<typename GetFindingRequestT = Model::GetFindingRequest>
        Model::GetFindingOutcomeCallable GetFindingCallable(const GetFindingRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::GetFinding, request);
        }
 
        template<typename GetFindingRequestT = Model::GetFindingRequest>
        void GetFindingAsync(const GetFindingRequestT& request, const GetFindingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::GetFinding, request, handler, context);
        }
 
        virtual Model::GetFindingRecommendationOutcome GetFindingRecommendation(const Model::GetFindingRecommendationRequest& request) const;
 
        template<typename GetFindingRecommendationRequestT = Model::GetFindingRecommendationRequest>
        Model::GetFindingRecommendationOutcomeCallable GetFindingRecommendationCallable(const GetFindingRecommendationRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::GetFindingRecommendation, request);
        }
 
        template<typename GetFindingRecommendationRequestT = Model::GetFindingRecommendationRequest>
        void GetFindingRecommendationAsync(const GetFindingRecommendationRequestT& request, const GetFindingRecommendationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::GetFindingRecommendation, request, handler, context);
        }
 
        virtual Model::GetFindingV2Outcome GetFindingV2(const Model::GetFindingV2Request& request) const;
 
        template<typename GetFindingV2RequestT = Model::GetFindingV2Request>
        Model::GetFindingV2OutcomeCallable GetFindingV2Callable(const GetFindingV2RequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::GetFindingV2, request);
        }
 
        template<typename GetFindingV2RequestT = Model::GetFindingV2Request>
        void GetFindingV2Async(const GetFindingV2RequestT& request, const GetFindingV2ResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::GetFindingV2, request, handler, context);
        }
 
        virtual Model::GetGeneratedPolicyOutcome GetGeneratedPolicy(const Model::GetGeneratedPolicyRequest& request) const;
 
        template<typename GetGeneratedPolicyRequestT = Model::GetGeneratedPolicyRequest>
        Model::GetGeneratedPolicyOutcomeCallable GetGeneratedPolicyCallable(const GetGeneratedPolicyRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::GetGeneratedPolicy, request);
        }
 
        template<typename GetGeneratedPolicyRequestT = Model::GetGeneratedPolicyRequest>
        void GetGeneratedPolicyAsync(const GetGeneratedPolicyRequestT& request, const GetGeneratedPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::GetGeneratedPolicy, request, handler, context);
        }
 
        virtual Model::ListAccessPreviewFindingsOutcome ListAccessPreviewFindings(const Model::ListAccessPreviewFindingsRequest& request) const;
 
        template<typename ListAccessPreviewFindingsRequestT = Model::ListAccessPreviewFindingsRequest>
        Model::ListAccessPreviewFindingsOutcomeCallable ListAccessPreviewFindingsCallable(const ListAccessPreviewFindingsRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::ListAccessPreviewFindings, request);
        }
 
        template<typename ListAccessPreviewFindingsRequestT = Model::ListAccessPreviewFindingsRequest>
        void ListAccessPreviewFindingsAsync(const ListAccessPreviewFindingsRequestT& request, const ListAccessPreviewFindingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::ListAccessPreviewFindings, request, handler, context);
        }
 
        virtual Model::ListAccessPreviewsOutcome ListAccessPreviews(const Model::ListAccessPreviewsRequest& request) const;
 
        template<typename ListAccessPreviewsRequestT = Model::ListAccessPreviewsRequest>
        Model::ListAccessPreviewsOutcomeCallable ListAccessPreviewsCallable(const ListAccessPreviewsRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::ListAccessPreviews, request);
        }
 
        template<typename ListAccessPreviewsRequestT = Model::ListAccessPreviewsRequest>
        void ListAccessPreviewsAsync(const ListAccessPreviewsRequestT& request, const ListAccessPreviewsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::ListAccessPreviews, request, handler, context);
        }
 
        virtual Model::ListAnalyzedResourcesOutcome ListAnalyzedResources(const Model::ListAnalyzedResourcesRequest& request) const;
 
        template<typename ListAnalyzedResourcesRequestT = Model::ListAnalyzedResourcesRequest>
        Model::ListAnalyzedResourcesOutcomeCallable ListAnalyzedResourcesCallable(const ListAnalyzedResourcesRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::ListAnalyzedResources, request);
        }
 
        template<typename ListAnalyzedResourcesRequestT = Model::ListAnalyzedResourcesRequest>
        void ListAnalyzedResourcesAsync(const ListAnalyzedResourcesRequestT& request, const ListAnalyzedResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::ListAnalyzedResources, request, handler, context);
        }
 
        virtual Model::ListAnalyzersOutcome ListAnalyzers(const Model::ListAnalyzersRequest& request = {}) const;
 
        template<typename ListAnalyzersRequestT = Model::ListAnalyzersRequest>
        Model::ListAnalyzersOutcomeCallable ListAnalyzersCallable(const ListAnalyzersRequestT& request = {}) const
        {
            return SubmitCallable(&AccessAnalyzerClient::ListAnalyzers, request);
        }
 
        template<typename ListAnalyzersRequestT = Model::ListAnalyzersRequest>
        void ListAnalyzersAsync(const ListAnalyzersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAnalyzersRequestT& request = {}) const
        {
            return SubmitAsync(&AccessAnalyzerClient::ListAnalyzers, request, handler, context);
        }
 
        virtual Model::ListArchiveRulesOutcome ListArchiveRules(const Model::ListArchiveRulesRequest& request) const;
 
        template<typename ListArchiveRulesRequestT = Model::ListArchiveRulesRequest>
        Model::ListArchiveRulesOutcomeCallable ListArchiveRulesCallable(const ListArchiveRulesRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::ListArchiveRules, request);
        }
 
        template<typename ListArchiveRulesRequestT = Model::ListArchiveRulesRequest>
        void ListArchiveRulesAsync(const ListArchiveRulesRequestT& request, const ListArchiveRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::ListArchiveRules, 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(&AccessAnalyzerClient::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(&AccessAnalyzerClient::ListFindings, request, handler, context);
        }
 
        virtual Model::ListFindingsV2Outcome ListFindingsV2(const Model::ListFindingsV2Request& request) const;
 
        template<typename ListFindingsV2RequestT = Model::ListFindingsV2Request>
        Model::ListFindingsV2OutcomeCallable ListFindingsV2Callable(const ListFindingsV2RequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::ListFindingsV2, request);
        }
 
        template<typename ListFindingsV2RequestT = Model::ListFindingsV2Request>
        void ListFindingsV2Async(const ListFindingsV2RequestT& request, const ListFindingsV2ResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::ListFindingsV2, request, handler, context);
        }
 
        virtual Model::ListPolicyGenerationsOutcome ListPolicyGenerations(const Model::ListPolicyGenerationsRequest& request = {}) const;
 
        template<typename ListPolicyGenerationsRequestT = Model::ListPolicyGenerationsRequest>
        Model::ListPolicyGenerationsOutcomeCallable ListPolicyGenerationsCallable(const ListPolicyGenerationsRequestT& request = {}) const
        {
            return SubmitCallable(&AccessAnalyzerClient::ListPolicyGenerations, request);
        }
 
        template<typename ListPolicyGenerationsRequestT = Model::ListPolicyGenerationsRequest>
        void ListPolicyGenerationsAsync(const ListPolicyGenerationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPolicyGenerationsRequestT& request = {}) const
        {
            return SubmitAsync(&AccessAnalyzerClient::ListPolicyGenerations, 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(&AccessAnalyzerClient::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(&AccessAnalyzerClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::StartPolicyGenerationOutcome StartPolicyGeneration(const Model::StartPolicyGenerationRequest& request) const;
 
        template<typename StartPolicyGenerationRequestT = Model::StartPolicyGenerationRequest>
        Model::StartPolicyGenerationOutcomeCallable StartPolicyGenerationCallable(const StartPolicyGenerationRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::StartPolicyGeneration, request);
        }
 
        template<typename StartPolicyGenerationRequestT = Model::StartPolicyGenerationRequest>
        void StartPolicyGenerationAsync(const StartPolicyGenerationRequestT& request, const StartPolicyGenerationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::StartPolicyGeneration, request, handler, context);
        }
 
        virtual Model::StartResourceScanOutcome StartResourceScan(const Model::StartResourceScanRequest& request) const;
 
        template<typename StartResourceScanRequestT = Model::StartResourceScanRequest>
        Model::StartResourceScanOutcomeCallable StartResourceScanCallable(const StartResourceScanRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::StartResourceScan, request);
        }
 
        template<typename StartResourceScanRequestT = Model::StartResourceScanRequest>
        void StartResourceScanAsync(const StartResourceScanRequestT& request, const StartResourceScanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::StartResourceScan, 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(&AccessAnalyzerClient::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(&AccessAnalyzerClient::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(&AccessAnalyzerClient::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(&AccessAnalyzerClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateArchiveRuleOutcome UpdateArchiveRule(const Model::UpdateArchiveRuleRequest& request) const;
 
        template<typename UpdateArchiveRuleRequestT = Model::UpdateArchiveRuleRequest>
        Model::UpdateArchiveRuleOutcomeCallable UpdateArchiveRuleCallable(const UpdateArchiveRuleRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::UpdateArchiveRule, request);
        }
 
        template<typename UpdateArchiveRuleRequestT = Model::UpdateArchiveRuleRequest>
        void UpdateArchiveRuleAsync(const UpdateArchiveRuleRequestT& request, const UpdateArchiveRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::UpdateArchiveRule, request, handler, context);
        }
 
        virtual Model::UpdateFindingsOutcome UpdateFindings(const Model::UpdateFindingsRequest& request) const;
 
        template<typename UpdateFindingsRequestT = Model::UpdateFindingsRequest>
        Model::UpdateFindingsOutcomeCallable UpdateFindingsCallable(const UpdateFindingsRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::UpdateFindings, request);
        }
 
        template<typename UpdateFindingsRequestT = Model::UpdateFindingsRequest>
        void UpdateFindingsAsync(const UpdateFindingsRequestT& request, const UpdateFindingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::UpdateFindings, request, handler, context);
        }
 
        virtual Model::ValidatePolicyOutcome ValidatePolicy(const Model::ValidatePolicyRequest& request) const;
 
        template<typename ValidatePolicyRequestT = Model::ValidatePolicyRequest>
        Model::ValidatePolicyOutcomeCallable ValidatePolicyCallable(const ValidatePolicyRequestT& request) const
        {
            return SubmitCallable(&AccessAnalyzerClient::ValidatePolicy, request);
        }
 
        template<typename ValidatePolicyRequestT = Model::ValidatePolicyRequest>
        void ValidatePolicyAsync(const ValidatePolicyRequestT& request, const ValidatePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccessAnalyzerClient::ValidatePolicy, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<AccessAnalyzerEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<AccessAnalyzerClient>;
      void init(const AccessAnalyzerClientConfiguration& clientConfiguration);
 
      AccessAnalyzerClientConfiguration m_clientConfiguration;
      std::shared_ptr<AccessAnalyzerEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace AccessAnalyzer
} // namespace Aws