VerifiedPermissionsClient.h

 
#pragma once
#include <aws/verifiedpermissions/VerifiedPermissions_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/verifiedpermissions/VerifiedPermissionsServiceClientModel.h>
 
namespace Aws
{
namespace VerifiedPermissions
{
  class AWS_VERIFIEDPERMISSIONS_API VerifiedPermissionsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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::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::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::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::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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<VerifiedPermissionsEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<VerifiedPermissionsClient>;
      void init(const VerifiedPermissionsClientConfiguration& clientConfiguration);
 
      VerifiedPermissionsClientConfiguration m_clientConfiguration;
      std::shared_ptr<VerifiedPermissionsEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace VerifiedPermissions
} // namespace Aws