VerifiedPermissionsClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/verifiedpermissions/VerifiedPermissionsPaginationBase.h>
#include <aws/verifiedpermissions/VerifiedPermissionsServiceClientModel.h>
#include <aws/verifiedpermissions/VerifiedPermissionsWaiter.h>
#include <aws/verifiedpermissions/VerifiedPermissions_EXPORTS.h>
 
namespace Aws {
namespace VerifiedPermissions {
class AWS_VERIFIEDPERMISSIONS_API VerifiedPermissionsClient : public Aws::Client::AWSJsonClient,
                                                              public Aws::Client::ClientWithAsyncTemplateMethods<VerifiedPermissionsClient>,
                                                              public VerifiedPermissionsPaginationBase<VerifiedPermissionsClient>,
                                                              public VerifiedPermissionsWaiter<VerifiedPermissionsClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef VerifiedPermissionsClientConfiguration ClientConfigurationType;
  typedef VerifiedPermissionsEndpointProvider EndpointProviderType;
 
  VerifiedPermissionsClient(const Aws::VerifiedPermissions::VerifiedPermissionsClientConfiguration& clientConfiguration =
                                Aws::VerifiedPermissions::VerifiedPermissionsClientConfiguration(),
                            std::shared_ptr<VerifiedPermissionsEndpointProviderBase> endpointProvider = nullptr);
 
  VerifiedPermissionsClient(const Aws::Auth::AWSCredentials& credentials,
                            std::shared_ptr<VerifiedPermissionsEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::VerifiedPermissions::VerifiedPermissionsClientConfiguration& clientConfiguration =
                                Aws::VerifiedPermissions::VerifiedPermissionsClientConfiguration());
 
  VerifiedPermissionsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            std::shared_ptr<VerifiedPermissionsEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::VerifiedPermissions::VerifiedPermissionsClientConfiguration& clientConfiguration =
                                Aws::VerifiedPermissions::VerifiedPermissionsClientConfiguration());
 
  /* Legacy constructors due deprecation */
  VerifiedPermissionsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  VerifiedPermissionsClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  VerifiedPermissionsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~VerifiedPermissionsClient();
 
  virtual Model::BatchGetPolicyOutcome BatchGetPolicy(const Model::BatchGetPolicyRequest& request) const;
 
  template <typename BatchGetPolicyRequestT = Model::BatchGetPolicyRequest>
  Model::BatchGetPolicyOutcomeCallable BatchGetPolicyCallable(const BatchGetPolicyRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::BatchGetPolicy, request);
  }
 
  template <typename BatchGetPolicyRequestT = Model::BatchGetPolicyRequest>
  void BatchGetPolicyAsync(const BatchGetPolicyRequestT& request, const BatchGetPolicyResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::BatchGetPolicy, request, handler, context);
  }
 
  virtual Model::BatchIsAuthorizedOutcome BatchIsAuthorized(const Model::BatchIsAuthorizedRequest& request) const;
 
  template <typename BatchIsAuthorizedRequestT = Model::BatchIsAuthorizedRequest>
  Model::BatchIsAuthorizedOutcomeCallable BatchIsAuthorizedCallable(const BatchIsAuthorizedRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::BatchIsAuthorized, request);
  }
 
  template <typename BatchIsAuthorizedRequestT = Model::BatchIsAuthorizedRequest>
  void BatchIsAuthorizedAsync(const BatchIsAuthorizedRequestT& request, const BatchIsAuthorizedResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::BatchIsAuthorized, request, handler, context);
  }
 
  virtual Model::BatchIsAuthorizedWithTokenOutcome BatchIsAuthorizedWithToken(
      const Model::BatchIsAuthorizedWithTokenRequest& request) const;
 
  template <typename BatchIsAuthorizedWithTokenRequestT = Model::BatchIsAuthorizedWithTokenRequest>
  Model::BatchIsAuthorizedWithTokenOutcomeCallable BatchIsAuthorizedWithTokenCallable(
      const BatchIsAuthorizedWithTokenRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::BatchIsAuthorizedWithToken, request);
  }
 
  template <typename BatchIsAuthorizedWithTokenRequestT = Model::BatchIsAuthorizedWithTokenRequest>
  void BatchIsAuthorizedWithTokenAsync(const BatchIsAuthorizedWithTokenRequestT& request,
                                       const BatchIsAuthorizedWithTokenResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::BatchIsAuthorizedWithToken, request, handler, context);
  }
 
  virtual Model::CreateIdentitySourceOutcome CreateIdentitySource(const Model::CreateIdentitySourceRequest& request) const;
 
  template <typename CreateIdentitySourceRequestT = Model::CreateIdentitySourceRequest>
  Model::CreateIdentitySourceOutcomeCallable CreateIdentitySourceCallable(const CreateIdentitySourceRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::CreateIdentitySource, request);
  }
 
  template <typename CreateIdentitySourceRequestT = Model::CreateIdentitySourceRequest>
  void CreateIdentitySourceAsync(const CreateIdentitySourceRequestT& request, const CreateIdentitySourceResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::CreateIdentitySource, request, handler, context);
  }
 
  virtual Model::CreatePolicyOutcome CreatePolicy(const Model::CreatePolicyRequest& request) const;
 
  template <typename CreatePolicyRequestT = Model::CreatePolicyRequest>
  Model::CreatePolicyOutcomeCallable CreatePolicyCallable(const CreatePolicyRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::CreatePolicy, request);
  }
 
  template <typename CreatePolicyRequestT = Model::CreatePolicyRequest>
  void CreatePolicyAsync(const CreatePolicyRequestT& request, const CreatePolicyResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::CreatePolicy, request, handler, context);
  }
 
  virtual Model::CreatePolicyStoreOutcome CreatePolicyStore(const Model::CreatePolicyStoreRequest& request) const;
 
  template <typename CreatePolicyStoreRequestT = Model::CreatePolicyStoreRequest>
  Model::CreatePolicyStoreOutcomeCallable CreatePolicyStoreCallable(const CreatePolicyStoreRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::CreatePolicyStore, request);
  }
 
  template <typename CreatePolicyStoreRequestT = Model::CreatePolicyStoreRequest>
  void CreatePolicyStoreAsync(const CreatePolicyStoreRequestT& request, const CreatePolicyStoreResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::CreatePolicyStore, request, handler, context);
  }
 
  virtual Model::CreatePolicyStoreAliasOutcome CreatePolicyStoreAlias(const Model::CreatePolicyStoreAliasRequest& request) const;
 
  template <typename CreatePolicyStoreAliasRequestT = Model::CreatePolicyStoreAliasRequest>
  Model::CreatePolicyStoreAliasOutcomeCallable CreatePolicyStoreAliasCallable(const CreatePolicyStoreAliasRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::CreatePolicyStoreAlias, request);
  }
 
  template <typename CreatePolicyStoreAliasRequestT = Model::CreatePolicyStoreAliasRequest>
  void CreatePolicyStoreAliasAsync(const CreatePolicyStoreAliasRequestT& request,
                                   const CreatePolicyStoreAliasResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::CreatePolicyStoreAlias, request, handler, context);
  }
 
  virtual Model::CreatePolicyTemplateOutcome CreatePolicyTemplate(const Model::CreatePolicyTemplateRequest& request) const;
 
  template <typename CreatePolicyTemplateRequestT = Model::CreatePolicyTemplateRequest>
  Model::CreatePolicyTemplateOutcomeCallable CreatePolicyTemplateCallable(const CreatePolicyTemplateRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::CreatePolicyTemplate, request);
  }
 
  template <typename CreatePolicyTemplateRequestT = Model::CreatePolicyTemplateRequest>
  void CreatePolicyTemplateAsync(const CreatePolicyTemplateRequestT& request, const CreatePolicyTemplateResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::CreatePolicyTemplate, request, handler, context);
  }
 
  virtual Model::DeleteIdentitySourceOutcome DeleteIdentitySource(const Model::DeleteIdentitySourceRequest& request) const;
 
  template <typename DeleteIdentitySourceRequestT = Model::DeleteIdentitySourceRequest>
  Model::DeleteIdentitySourceOutcomeCallable DeleteIdentitySourceCallable(const DeleteIdentitySourceRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::DeleteIdentitySource, request);
  }
 
  template <typename DeleteIdentitySourceRequestT = Model::DeleteIdentitySourceRequest>
  void DeleteIdentitySourceAsync(const DeleteIdentitySourceRequestT& request, const DeleteIdentitySourceResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::DeleteIdentitySource, request, handler, context);
  }
 
  virtual Model::DeletePolicyOutcome DeletePolicy(const Model::DeletePolicyRequest& request) const;
 
  template <typename DeletePolicyRequestT = Model::DeletePolicyRequest>
  Model::DeletePolicyOutcomeCallable DeletePolicyCallable(const DeletePolicyRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::DeletePolicy, request);
  }
 
  template <typename DeletePolicyRequestT = Model::DeletePolicyRequest>
  void DeletePolicyAsync(const DeletePolicyRequestT& request, const DeletePolicyResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::DeletePolicy, request, handler, context);
  }
 
  virtual Model::DeletePolicyStoreOutcome DeletePolicyStore(const Model::DeletePolicyStoreRequest& request) const;
 
  template <typename DeletePolicyStoreRequestT = Model::DeletePolicyStoreRequest>
  Model::DeletePolicyStoreOutcomeCallable DeletePolicyStoreCallable(const DeletePolicyStoreRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::DeletePolicyStore, request);
  }
 
  template <typename DeletePolicyStoreRequestT = Model::DeletePolicyStoreRequest>
  void DeletePolicyStoreAsync(const DeletePolicyStoreRequestT& request, const DeletePolicyStoreResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::DeletePolicyStore, request, handler, context);
  }
 
  virtual Model::DeletePolicyStoreAliasOutcome DeletePolicyStoreAlias(const Model::DeletePolicyStoreAliasRequest& request) const;
 
  template <typename DeletePolicyStoreAliasRequestT = Model::DeletePolicyStoreAliasRequest>
  Model::DeletePolicyStoreAliasOutcomeCallable DeletePolicyStoreAliasCallable(const DeletePolicyStoreAliasRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::DeletePolicyStoreAlias, request);
  }
 
  template <typename DeletePolicyStoreAliasRequestT = Model::DeletePolicyStoreAliasRequest>
  void DeletePolicyStoreAliasAsync(const DeletePolicyStoreAliasRequestT& request,
                                   const DeletePolicyStoreAliasResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::DeletePolicyStoreAlias, request, handler, context);
  }
 
  virtual Model::DeletePolicyTemplateOutcome DeletePolicyTemplate(const Model::DeletePolicyTemplateRequest& request) const;
 
  template <typename DeletePolicyTemplateRequestT = Model::DeletePolicyTemplateRequest>
  Model::DeletePolicyTemplateOutcomeCallable DeletePolicyTemplateCallable(const DeletePolicyTemplateRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::DeletePolicyTemplate, request);
  }
 
  template <typename DeletePolicyTemplateRequestT = Model::DeletePolicyTemplateRequest>
  void DeletePolicyTemplateAsync(const DeletePolicyTemplateRequestT& request, const DeletePolicyTemplateResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::DeletePolicyTemplate, request, handler, context);
  }
 
  virtual Model::GetIdentitySourceOutcome GetIdentitySource(const Model::GetIdentitySourceRequest& request) const;
 
  template <typename GetIdentitySourceRequestT = Model::GetIdentitySourceRequest>
  Model::GetIdentitySourceOutcomeCallable GetIdentitySourceCallable(const GetIdentitySourceRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::GetIdentitySource, request);
  }
 
  template <typename GetIdentitySourceRequestT = Model::GetIdentitySourceRequest>
  void GetIdentitySourceAsync(const GetIdentitySourceRequestT& request, const GetIdentitySourceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::GetIdentitySource, request, handler, context);
  }
 
  virtual Model::GetPolicyOutcome GetPolicy(const Model::GetPolicyRequest& request) const;
 
  template <typename GetPolicyRequestT = Model::GetPolicyRequest>
  Model::GetPolicyOutcomeCallable GetPolicyCallable(const GetPolicyRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::GetPolicy, request);
  }
 
  template <typename GetPolicyRequestT = Model::GetPolicyRequest>
  void GetPolicyAsync(const GetPolicyRequestT& request, const GetPolicyResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::GetPolicy, request, handler, context);
  }
 
  virtual Model::GetPolicyStoreOutcome GetPolicyStore(const Model::GetPolicyStoreRequest& request) const;
 
  template <typename GetPolicyStoreRequestT = Model::GetPolicyStoreRequest>
  Model::GetPolicyStoreOutcomeCallable GetPolicyStoreCallable(const GetPolicyStoreRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::GetPolicyStore, request);
  }
 
  template <typename GetPolicyStoreRequestT = Model::GetPolicyStoreRequest>
  void GetPolicyStoreAsync(const GetPolicyStoreRequestT& request, const GetPolicyStoreResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::GetPolicyStore, request, handler, context);
  }
 
  virtual Model::GetPolicyStoreAliasOutcome GetPolicyStoreAlias(const Model::GetPolicyStoreAliasRequest& request) const;
 
  template <typename GetPolicyStoreAliasRequestT = Model::GetPolicyStoreAliasRequest>
  Model::GetPolicyStoreAliasOutcomeCallable GetPolicyStoreAliasCallable(const GetPolicyStoreAliasRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::GetPolicyStoreAlias, request);
  }
 
  template <typename GetPolicyStoreAliasRequestT = Model::GetPolicyStoreAliasRequest>
  void GetPolicyStoreAliasAsync(const GetPolicyStoreAliasRequestT& request, const GetPolicyStoreAliasResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::GetPolicyStoreAlias, request, handler, context);
  }
 
  virtual Model::GetPolicyTemplateOutcome GetPolicyTemplate(const Model::GetPolicyTemplateRequest& request) const;
 
  template <typename GetPolicyTemplateRequestT = Model::GetPolicyTemplateRequest>
  Model::GetPolicyTemplateOutcomeCallable GetPolicyTemplateCallable(const GetPolicyTemplateRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::GetPolicyTemplate, request);
  }
 
  template <typename GetPolicyTemplateRequestT = Model::GetPolicyTemplateRequest>
  void GetPolicyTemplateAsync(const GetPolicyTemplateRequestT& request, const GetPolicyTemplateResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::GetPolicyTemplate, request, handler, context);
  }
 
  virtual Model::GetSchemaOutcome GetSchema(const Model::GetSchemaRequest& request) const;
 
  template <typename GetSchemaRequestT = Model::GetSchemaRequest>
  Model::GetSchemaOutcomeCallable GetSchemaCallable(const GetSchemaRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::GetSchema, request);
  }
 
  template <typename GetSchemaRequestT = Model::GetSchemaRequest>
  void GetSchemaAsync(const GetSchemaRequestT& request, const GetSchemaResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::GetSchema, request, handler, context);
  }
 
  virtual Model::IsAuthorizedOutcome IsAuthorized(const Model::IsAuthorizedRequest& request) const;
 
  template <typename IsAuthorizedRequestT = Model::IsAuthorizedRequest>
  Model::IsAuthorizedOutcomeCallable IsAuthorizedCallable(const IsAuthorizedRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::IsAuthorized, request);
  }
 
  template <typename IsAuthorizedRequestT = Model::IsAuthorizedRequest>
  void IsAuthorizedAsync(const IsAuthorizedRequestT& request, const IsAuthorizedResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::IsAuthorized, request, handler, context);
  }
 
  virtual Model::IsAuthorizedWithTokenOutcome IsAuthorizedWithToken(const Model::IsAuthorizedWithTokenRequest& request) const;
 
  template <typename IsAuthorizedWithTokenRequestT = Model::IsAuthorizedWithTokenRequest>
  Model::IsAuthorizedWithTokenOutcomeCallable IsAuthorizedWithTokenCallable(const IsAuthorizedWithTokenRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::IsAuthorizedWithToken, request);
  }
 
  template <typename IsAuthorizedWithTokenRequestT = Model::IsAuthorizedWithTokenRequest>
  void IsAuthorizedWithTokenAsync(const IsAuthorizedWithTokenRequestT& request, const IsAuthorizedWithTokenResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::IsAuthorizedWithToken, request, handler, context);
  }
 
  virtual Model::ListIdentitySourcesOutcome ListIdentitySources(const Model::ListIdentitySourcesRequest& request) const;
 
  template <typename ListIdentitySourcesRequestT = Model::ListIdentitySourcesRequest>
  Model::ListIdentitySourcesOutcomeCallable ListIdentitySourcesCallable(const ListIdentitySourcesRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::ListIdentitySources, request);
  }
 
  template <typename ListIdentitySourcesRequestT = Model::ListIdentitySourcesRequest>
  void ListIdentitySourcesAsync(const ListIdentitySourcesRequestT& request, const ListIdentitySourcesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::ListIdentitySources, request, handler, context);
  }
 
  virtual Model::ListPoliciesOutcome ListPolicies(const Model::ListPoliciesRequest& request) const;
 
  template <typename ListPoliciesRequestT = Model::ListPoliciesRequest>
  Model::ListPoliciesOutcomeCallable ListPoliciesCallable(const ListPoliciesRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::ListPolicies, request);
  }
 
  template <typename ListPoliciesRequestT = Model::ListPoliciesRequest>
  void ListPoliciesAsync(const ListPoliciesRequestT& request, const ListPoliciesResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::ListPolicies, request, handler, context);
  }
 
  virtual Model::ListPolicyStoreAliasesOutcome ListPolicyStoreAliases(const Model::ListPolicyStoreAliasesRequest& request = {}) const;
 
  template <typename ListPolicyStoreAliasesRequestT = Model::ListPolicyStoreAliasesRequest>
  Model::ListPolicyStoreAliasesOutcomeCallable ListPolicyStoreAliasesCallable(const ListPolicyStoreAliasesRequestT& request = {}) const {
    return SubmitCallable(&VerifiedPermissionsClient::ListPolicyStoreAliases, request);
  }
 
  template <typename ListPolicyStoreAliasesRequestT = Model::ListPolicyStoreAliasesRequest>
  void ListPolicyStoreAliasesAsync(const ListPolicyStoreAliasesResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListPolicyStoreAliasesRequestT& request = {}) const {
    return SubmitAsync(&VerifiedPermissionsClient::ListPolicyStoreAliases, request, handler, context);
  }
 
  virtual Model::ListPolicyStoresOutcome ListPolicyStores(const Model::ListPolicyStoresRequest& request = {}) const;
 
  template <typename ListPolicyStoresRequestT = Model::ListPolicyStoresRequest>
  Model::ListPolicyStoresOutcomeCallable ListPolicyStoresCallable(const ListPolicyStoresRequestT& request = {}) const {
    return SubmitCallable(&VerifiedPermissionsClient::ListPolicyStores, request);
  }
 
  template <typename ListPolicyStoresRequestT = Model::ListPolicyStoresRequest>
  void ListPolicyStoresAsync(const ListPolicyStoresResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListPolicyStoresRequestT& request = {}) const {
    return SubmitAsync(&VerifiedPermissionsClient::ListPolicyStores, request, handler, context);
  }
 
  virtual Model::ListPolicyTemplatesOutcome ListPolicyTemplates(const Model::ListPolicyTemplatesRequest& request) const;
 
  template <typename ListPolicyTemplatesRequestT = Model::ListPolicyTemplatesRequest>
  Model::ListPolicyTemplatesOutcomeCallable ListPolicyTemplatesCallable(const ListPolicyTemplatesRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::ListPolicyTemplates, request);
  }
 
  template <typename ListPolicyTemplatesRequestT = Model::ListPolicyTemplatesRequest>
  void ListPolicyTemplatesAsync(const ListPolicyTemplatesRequestT& request, const ListPolicyTemplatesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::ListPolicyTemplates, 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(&VerifiedPermissionsClient::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(&VerifiedPermissionsClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::PutSchemaOutcome PutSchema(const Model::PutSchemaRequest& request) const;
 
  template <typename PutSchemaRequestT = Model::PutSchemaRequest>
  Model::PutSchemaOutcomeCallable PutSchemaCallable(const PutSchemaRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::PutSchema, request);
  }
 
  template <typename PutSchemaRequestT = Model::PutSchemaRequest>
  void PutSchemaAsync(const PutSchemaRequestT& request, const PutSchemaResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::PutSchema, 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(&VerifiedPermissionsClient::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(&VerifiedPermissionsClient::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(&VerifiedPermissionsClient::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(&VerifiedPermissionsClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateIdentitySourceOutcome UpdateIdentitySource(const Model::UpdateIdentitySourceRequest& request) const;
 
  template <typename UpdateIdentitySourceRequestT = Model::UpdateIdentitySourceRequest>
  Model::UpdateIdentitySourceOutcomeCallable UpdateIdentitySourceCallable(const UpdateIdentitySourceRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::UpdateIdentitySource, request);
  }
 
  template <typename UpdateIdentitySourceRequestT = Model::UpdateIdentitySourceRequest>
  void UpdateIdentitySourceAsync(const UpdateIdentitySourceRequestT& request, const UpdateIdentitySourceResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::UpdateIdentitySource, request, handler, context);
  }
 
  virtual Model::UpdatePolicyOutcome UpdatePolicy(const Model::UpdatePolicyRequest& request) const;
 
  template <typename UpdatePolicyRequestT = Model::UpdatePolicyRequest>
  Model::UpdatePolicyOutcomeCallable UpdatePolicyCallable(const UpdatePolicyRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::UpdatePolicy, request);
  }
 
  template <typename UpdatePolicyRequestT = Model::UpdatePolicyRequest>
  void UpdatePolicyAsync(const UpdatePolicyRequestT& request, const UpdatePolicyResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::UpdatePolicy, request, handler, context);
  }
 
  virtual Model::UpdatePolicyStoreOutcome UpdatePolicyStore(const Model::UpdatePolicyStoreRequest& request) const;
 
  template <typename UpdatePolicyStoreRequestT = Model::UpdatePolicyStoreRequest>
  Model::UpdatePolicyStoreOutcomeCallable UpdatePolicyStoreCallable(const UpdatePolicyStoreRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::UpdatePolicyStore, request);
  }
 
  template <typename UpdatePolicyStoreRequestT = Model::UpdatePolicyStoreRequest>
  void UpdatePolicyStoreAsync(const UpdatePolicyStoreRequestT& request, const UpdatePolicyStoreResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::UpdatePolicyStore, request, handler, context);
  }
 
  virtual Model::UpdatePolicyTemplateOutcome UpdatePolicyTemplate(const Model::UpdatePolicyTemplateRequest& request) const;
 
  template <typename UpdatePolicyTemplateRequestT = Model::UpdatePolicyTemplateRequest>
  Model::UpdatePolicyTemplateOutcomeCallable UpdatePolicyTemplateCallable(const UpdatePolicyTemplateRequestT& request) const {
    return SubmitCallable(&VerifiedPermissionsClient::UpdatePolicyTemplate, request);
  }
 
  template <typename UpdatePolicyTemplateRequestT = Model::UpdatePolicyTemplateRequest>
  void UpdatePolicyTemplateAsync(const UpdatePolicyTemplateRequestT& request, const UpdatePolicyTemplateResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&VerifiedPermissionsClient::UpdatePolicyTemplate, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<VerifiedPermissionsEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<VerifiedPermissionsClient>;
  void init(const VerifiedPermissionsClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, VerifiedPermissionsError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  VerifiedPermissionsClientConfiguration m_clientConfiguration;
  std::shared_ptr<VerifiedPermissionsEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace VerifiedPermissions
}  // namespace Aws