AccessAnalyzerClient.h

 
#pragma once
#include <aws/accessanalyzer/AccessAnalyzerPaginationBase.h>
#include <aws/accessanalyzer/AccessAnalyzerServiceClientModel.h>
#include <aws/accessanalyzer/AccessAnalyzerWaiter.h>
#include <aws/accessanalyzer/AccessAnalyzer_EXPORTS.h>
#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>
 
namespace Aws {
namespace AccessAnalyzer {
class AWS_ACCESSANALYZER_API AccessAnalyzerClient : public Aws::Client::AWSJsonClient,
                                                    public Aws::Client::ClientWithAsyncTemplateMethods<AccessAnalyzerClient>,
                                                    public AccessAnalyzerPaginationBase<AccessAnalyzerClient>,
                                                    public AccessAnalyzerWaiter<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::CreateServiceLinkedAnalyzerOutcome CreateServiceLinkedAnalyzer(
      const Model::CreateServiceLinkedAnalyzerRequest& request) const;
 
  template <typename CreateServiceLinkedAnalyzerRequestT = Model::CreateServiceLinkedAnalyzerRequest>
  Model::CreateServiceLinkedAnalyzerOutcomeCallable CreateServiceLinkedAnalyzerCallable(
      const CreateServiceLinkedAnalyzerRequestT& request) const {
    return SubmitCallable(&AccessAnalyzerClient::CreateServiceLinkedAnalyzer, request);
  }
 
  template <typename CreateServiceLinkedAnalyzerRequestT = Model::CreateServiceLinkedAnalyzerRequest>
  void CreateServiceLinkedAnalyzerAsync(const CreateServiceLinkedAnalyzerRequestT& request,
                                        const CreateServiceLinkedAnalyzerResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AccessAnalyzerClient::CreateServiceLinkedAnalyzer, 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::DeleteServiceLinkedAnalyzerOutcome DeleteServiceLinkedAnalyzer(
      const Model::DeleteServiceLinkedAnalyzerRequest& request) const;
 
  template <typename DeleteServiceLinkedAnalyzerRequestT = Model::DeleteServiceLinkedAnalyzerRequest>
  Model::DeleteServiceLinkedAnalyzerOutcomeCallable DeleteServiceLinkedAnalyzerCallable(
      const DeleteServiceLinkedAnalyzerRequestT& request) const {
    return SubmitCallable(&AccessAnalyzerClient::DeleteServiceLinkedAnalyzer, request);
  }
 
  template <typename DeleteServiceLinkedAnalyzerRequestT = Model::DeleteServiceLinkedAnalyzerRequest>
  void DeleteServiceLinkedAnalyzerAsync(const DeleteServiceLinkedAnalyzerRequestT& request,
                                        const DeleteServiceLinkedAnalyzerResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AccessAnalyzerClient::DeleteServiceLinkedAnalyzer, 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::GetFindingsStatisticsOutcome GetFindingsStatistics(const Model::GetFindingsStatisticsRequest& request) const;
 
  template <typename GetFindingsStatisticsRequestT = Model::GetFindingsStatisticsRequest>
  Model::GetFindingsStatisticsOutcomeCallable GetFindingsStatisticsCallable(const GetFindingsStatisticsRequestT& request) const {
    return SubmitCallable(&AccessAnalyzerClient::GetFindingsStatistics, request);
  }
 
  template <typename GetFindingsStatisticsRequestT = Model::GetFindingsStatisticsRequest>
  void GetFindingsStatisticsAsync(const GetFindingsStatisticsRequestT& request, const GetFindingsStatisticsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AccessAnalyzerClient::GetFindingsStatistics, 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::UpdateAnalyzerOutcome UpdateAnalyzer(const Model::UpdateAnalyzerRequest& request) const;
 
  template <typename UpdateAnalyzerRequestT = Model::UpdateAnalyzerRequest>
  Model::UpdateAnalyzerOutcomeCallable UpdateAnalyzerCallable(const UpdateAnalyzerRequestT& request) const {
    return SubmitCallable(&AccessAnalyzerClient::UpdateAnalyzer, request);
  }
 
  template <typename UpdateAnalyzerRequestT = Model::UpdateAnalyzerRequest>
  void UpdateAnalyzerAsync(const UpdateAnalyzerRequestT& request, const UpdateAnalyzerResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AccessAnalyzerClient::UpdateAnalyzer, 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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<AccessAnalyzerEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<AccessAnalyzerClient>;
  void init(const AccessAnalyzerClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, AccessAnalyzerError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  AccessAnalyzerClientConfiguration m_clientConfiguration;
  std::shared_ptr<AccessAnalyzerEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace AccessAnalyzer
}  // namespace Aws