SecurityLakeClient.h

 
#pragma once
#include <aws/securitylake/SecurityLake_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/securitylake/SecurityLakeServiceClientModel.h>
 
namespace Aws
{
namespace SecurityLake
{
  class AWS_SECURITYLAKE_API SecurityLakeClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<SecurityLakeClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef SecurityLakeClientConfiguration ClientConfigurationType;
      typedef SecurityLakeEndpointProvider EndpointProviderType;
 
        SecurityLakeClient(const Aws::SecurityLake::SecurityLakeClientConfiguration& clientConfiguration = Aws::SecurityLake::SecurityLakeClientConfiguration(),
                           std::shared_ptr<SecurityLakeEndpointProviderBase> endpointProvider = nullptr);
 
        SecurityLakeClient(const Aws::Auth::AWSCredentials& credentials,
                           std::shared_ptr<SecurityLakeEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::SecurityLake::SecurityLakeClientConfiguration& clientConfiguration = Aws::SecurityLake::SecurityLakeClientConfiguration());
 
        SecurityLakeClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           std::shared_ptr<SecurityLakeEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::SecurityLake::SecurityLakeClientConfiguration& clientConfiguration = Aws::SecurityLake::SecurityLakeClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        SecurityLakeClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SecurityLakeClient(const Aws::Auth::AWSCredentials& credentials,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SecurityLakeClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~SecurityLakeClient();
 
        virtual Model::CreateAwsLogSourceOutcome CreateAwsLogSource(const Model::CreateAwsLogSourceRequest& request) const;
 
        template<typename CreateAwsLogSourceRequestT = Model::CreateAwsLogSourceRequest>
        Model::CreateAwsLogSourceOutcomeCallable CreateAwsLogSourceCallable(const CreateAwsLogSourceRequestT& request) const
        {
            return SubmitCallable(&SecurityLakeClient::CreateAwsLogSource, request);
        }
 
        template<typename CreateAwsLogSourceRequestT = Model::CreateAwsLogSourceRequest>
        void CreateAwsLogSourceAsync(const CreateAwsLogSourceRequestT& request, const CreateAwsLogSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SecurityLakeClient::CreateAwsLogSource, request, handler, context);
        }
 
        virtual Model::CreateCustomLogSourceOutcome CreateCustomLogSource(const Model::CreateCustomLogSourceRequest& request) const;
 
        template<typename CreateCustomLogSourceRequestT = Model::CreateCustomLogSourceRequest>
        Model::CreateCustomLogSourceOutcomeCallable CreateCustomLogSourceCallable(const CreateCustomLogSourceRequestT& request) const
        {
            return SubmitCallable(&SecurityLakeClient::CreateCustomLogSource, request);
        }
 
        template<typename CreateCustomLogSourceRequestT = Model::CreateCustomLogSourceRequest>
        void CreateCustomLogSourceAsync(const CreateCustomLogSourceRequestT& request, const CreateCustomLogSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SecurityLakeClient::CreateCustomLogSource, request, handler, context);
        }
 
        virtual Model::CreateDataLakeOutcome CreateDataLake(const Model::CreateDataLakeRequest& request) const;
 
        template<typename CreateDataLakeRequestT = Model::CreateDataLakeRequest>
        Model::CreateDataLakeOutcomeCallable CreateDataLakeCallable(const CreateDataLakeRequestT& request) const
        {
            return SubmitCallable(&SecurityLakeClient::CreateDataLake, request);
        }
 
        template<typename CreateDataLakeRequestT = Model::CreateDataLakeRequest>
        void CreateDataLakeAsync(const CreateDataLakeRequestT& request, const CreateDataLakeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SecurityLakeClient::CreateDataLake, request, handler, context);
        }
 
        virtual Model::CreateDataLakeExceptionSubscriptionOutcome CreateDataLakeExceptionSubscription(const Model::CreateDataLakeExceptionSubscriptionRequest& request) const;
 
        template<typename CreateDataLakeExceptionSubscriptionRequestT = Model::CreateDataLakeExceptionSubscriptionRequest>
        Model::CreateDataLakeExceptionSubscriptionOutcomeCallable CreateDataLakeExceptionSubscriptionCallable(const CreateDataLakeExceptionSubscriptionRequestT& request) const
        {
            return SubmitCallable(&SecurityLakeClient::CreateDataLakeExceptionSubscription, request);
        }
 
        template<typename CreateDataLakeExceptionSubscriptionRequestT = Model::CreateDataLakeExceptionSubscriptionRequest>
        void CreateDataLakeExceptionSubscriptionAsync(const CreateDataLakeExceptionSubscriptionRequestT& request, const CreateDataLakeExceptionSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SecurityLakeClient::CreateDataLakeExceptionSubscription, request, handler, context);
        }
 
        virtual Model::CreateDataLakeOrganizationConfigurationOutcome CreateDataLakeOrganizationConfiguration(const Model::CreateDataLakeOrganizationConfigurationRequest& request = {}) const;
 
        template<typename CreateDataLakeOrganizationConfigurationRequestT = Model::CreateDataLakeOrganizationConfigurationRequest>
        Model::CreateDataLakeOrganizationConfigurationOutcomeCallable CreateDataLakeOrganizationConfigurationCallable(const CreateDataLakeOrganizationConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&SecurityLakeClient::CreateDataLakeOrganizationConfiguration, request);
        }
 
        template<typename CreateDataLakeOrganizationConfigurationRequestT = Model::CreateDataLakeOrganizationConfigurationRequest>
        void CreateDataLakeOrganizationConfigurationAsync(const CreateDataLakeOrganizationConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateDataLakeOrganizationConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&SecurityLakeClient::CreateDataLakeOrganizationConfiguration, request, handler, context);
        }
 
        virtual Model::CreateSubscriberOutcome CreateSubscriber(const Model::CreateSubscriberRequest& request) const;
 
        template<typename CreateSubscriberRequestT = Model::CreateSubscriberRequest>
        Model::CreateSubscriberOutcomeCallable CreateSubscriberCallable(const CreateSubscriberRequestT& request) const
        {
            return SubmitCallable(&SecurityLakeClient::CreateSubscriber, request);
        }
 
        template<typename CreateSubscriberRequestT = Model::CreateSubscriberRequest>
        void CreateSubscriberAsync(const CreateSubscriberRequestT& request, const CreateSubscriberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SecurityLakeClient::CreateSubscriber, request, handler, context);
        }
 
        virtual Model::CreateSubscriberNotificationOutcome CreateSubscriberNotification(const Model::CreateSubscriberNotificationRequest& request) const;
 
        template<typename CreateSubscriberNotificationRequestT = Model::CreateSubscriberNotificationRequest>
        Model::CreateSubscriberNotificationOutcomeCallable CreateSubscriberNotificationCallable(const CreateSubscriberNotificationRequestT& request) const
        {
            return SubmitCallable(&SecurityLakeClient::CreateSubscriberNotification, request);
        }
 
        template<typename CreateSubscriberNotificationRequestT = Model::CreateSubscriberNotificationRequest>
        void CreateSubscriberNotificationAsync(const CreateSubscriberNotificationRequestT& request, const CreateSubscriberNotificationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SecurityLakeClient::CreateSubscriberNotification, request, handler, context);
        }
 
        virtual Model::DeleteAwsLogSourceOutcome DeleteAwsLogSource(const Model::DeleteAwsLogSourceRequest& request) const;
 
        template<typename DeleteAwsLogSourceRequestT = Model::DeleteAwsLogSourceRequest>
        Model::DeleteAwsLogSourceOutcomeCallable DeleteAwsLogSourceCallable(const DeleteAwsLogSourceRequestT& request) const
        {
            return SubmitCallable(&SecurityLakeClient::DeleteAwsLogSource, request);
        }
 
        template<typename DeleteAwsLogSourceRequestT = Model::DeleteAwsLogSourceRequest>
        void DeleteAwsLogSourceAsync(const DeleteAwsLogSourceRequestT& request, const DeleteAwsLogSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SecurityLakeClient::DeleteAwsLogSource, request, handler, context);
        }
 
        virtual Model::DeleteCustomLogSourceOutcome DeleteCustomLogSource(const Model::DeleteCustomLogSourceRequest& request) const;
 
        template<typename DeleteCustomLogSourceRequestT = Model::DeleteCustomLogSourceRequest>
        Model::DeleteCustomLogSourceOutcomeCallable DeleteCustomLogSourceCallable(const DeleteCustomLogSourceRequestT& request) const
        {
            return SubmitCallable(&SecurityLakeClient::DeleteCustomLogSource, request);
        }
 
        template<typename DeleteCustomLogSourceRequestT = Model::DeleteCustomLogSourceRequest>
        void DeleteCustomLogSourceAsync(const DeleteCustomLogSourceRequestT& request, const DeleteCustomLogSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SecurityLakeClient::DeleteCustomLogSource, request, handler, context);
        }
 
        virtual Model::DeleteDataLakeOutcome DeleteDataLake(const Model::DeleteDataLakeRequest& request) const;
 
        template<typename DeleteDataLakeRequestT = Model::DeleteDataLakeRequest>
        Model::DeleteDataLakeOutcomeCallable DeleteDataLakeCallable(const DeleteDataLakeRequestT& request) const
        {
            return SubmitCallable(&SecurityLakeClient::DeleteDataLake, request);
        }
 
        template<typename DeleteDataLakeRequestT = Model::DeleteDataLakeRequest>
        void DeleteDataLakeAsync(const DeleteDataLakeRequestT& request, const DeleteDataLakeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SecurityLakeClient::DeleteDataLake, request, handler, context);
        }
 
        virtual Model::DeleteDataLakeExceptionSubscriptionOutcome DeleteDataLakeExceptionSubscription(const Model::DeleteDataLakeExceptionSubscriptionRequest& request = {}) const;
 
        template<typename DeleteDataLakeExceptionSubscriptionRequestT = Model::DeleteDataLakeExceptionSubscriptionRequest>
        Model::DeleteDataLakeExceptionSubscriptionOutcomeCallable DeleteDataLakeExceptionSubscriptionCallable(const DeleteDataLakeExceptionSubscriptionRequestT& request = {}) const
        {
            return SubmitCallable(&SecurityLakeClient::DeleteDataLakeExceptionSubscription, request);
        }
 
        template<typename DeleteDataLakeExceptionSubscriptionRequestT = Model::DeleteDataLakeExceptionSubscriptionRequest>
        void DeleteDataLakeExceptionSubscriptionAsync(const DeleteDataLakeExceptionSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteDataLakeExceptionSubscriptionRequestT& request = {}) const
        {
            return SubmitAsync(&SecurityLakeClient::DeleteDataLakeExceptionSubscription, request, handler, context);
        }
 
        virtual Model::DeleteDataLakeOrganizationConfigurationOutcome DeleteDataLakeOrganizationConfiguration(const Model::DeleteDataLakeOrganizationConfigurationRequest& request = {}) const;
 
        template<typename DeleteDataLakeOrganizationConfigurationRequestT = Model::DeleteDataLakeOrganizationConfigurationRequest>
        Model::DeleteDataLakeOrganizationConfigurationOutcomeCallable DeleteDataLakeOrganizationConfigurationCallable(const DeleteDataLakeOrganizationConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&SecurityLakeClient::DeleteDataLakeOrganizationConfiguration, request);
        }
 
        template<typename DeleteDataLakeOrganizationConfigurationRequestT = Model::DeleteDataLakeOrganizationConfigurationRequest>
        void DeleteDataLakeOrganizationConfigurationAsync(const DeleteDataLakeOrganizationConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteDataLakeOrganizationConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&SecurityLakeClient::DeleteDataLakeOrganizationConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteSubscriberOutcome DeleteSubscriber(const Model::DeleteSubscriberRequest& request) const;
 
        template<typename DeleteSubscriberRequestT = Model::DeleteSubscriberRequest>
        Model::DeleteSubscriberOutcomeCallable DeleteSubscriberCallable(const DeleteSubscriberRequestT& request) const
        {
            return SubmitCallable(&SecurityLakeClient::DeleteSubscriber, request);
        }
 
        template<typename DeleteSubscriberRequestT = Model::DeleteSubscriberRequest>
        void DeleteSubscriberAsync(const DeleteSubscriberRequestT& request, const DeleteSubscriberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SecurityLakeClient::DeleteSubscriber, request, handler, context);
        }
 
        virtual Model::DeleteSubscriberNotificationOutcome DeleteSubscriberNotification(const Model::DeleteSubscriberNotificationRequest& request) const;
 
        template<typename DeleteSubscriberNotificationRequestT = Model::DeleteSubscriberNotificationRequest>
        Model::DeleteSubscriberNotificationOutcomeCallable DeleteSubscriberNotificationCallable(const DeleteSubscriberNotificationRequestT& request) const
        {
            return SubmitCallable(&SecurityLakeClient::DeleteSubscriberNotification, request);
        }
 
        template<typename DeleteSubscriberNotificationRequestT = Model::DeleteSubscriberNotificationRequest>
        void DeleteSubscriberNotificationAsync(const DeleteSubscriberNotificationRequestT& request, const DeleteSubscriberNotificationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SecurityLakeClient::DeleteSubscriberNotification, request, handler, context);
        }
 
        virtual Model::DeregisterDataLakeDelegatedAdministratorOutcome DeregisterDataLakeDelegatedAdministrator(const Model::DeregisterDataLakeDelegatedAdministratorRequest& request = {}) const;
 
        template<typename DeregisterDataLakeDelegatedAdministratorRequestT = Model::DeregisterDataLakeDelegatedAdministratorRequest>
        Model::DeregisterDataLakeDelegatedAdministratorOutcomeCallable DeregisterDataLakeDelegatedAdministratorCallable(const DeregisterDataLakeDelegatedAdministratorRequestT& request = {}) const
        {
            return SubmitCallable(&SecurityLakeClient::DeregisterDataLakeDelegatedAdministrator, request);
        }
 
        template<typename DeregisterDataLakeDelegatedAdministratorRequestT = Model::DeregisterDataLakeDelegatedAdministratorRequest>
        void DeregisterDataLakeDelegatedAdministratorAsync(const DeregisterDataLakeDelegatedAdministratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeregisterDataLakeDelegatedAdministratorRequestT& request = {}) const
        {
            return SubmitAsync(&SecurityLakeClient::DeregisterDataLakeDelegatedAdministrator, request, handler, context);
        }
 
        virtual Model::GetDataLakeExceptionSubscriptionOutcome GetDataLakeExceptionSubscription(const Model::GetDataLakeExceptionSubscriptionRequest& request = {}) const;
 
        template<typename GetDataLakeExceptionSubscriptionRequestT = Model::GetDataLakeExceptionSubscriptionRequest>
        Model::GetDataLakeExceptionSubscriptionOutcomeCallable GetDataLakeExceptionSubscriptionCallable(const GetDataLakeExceptionSubscriptionRequestT& request = {}) const
        {
            return SubmitCallable(&SecurityLakeClient::GetDataLakeExceptionSubscription, request);
        }
 
        template<typename GetDataLakeExceptionSubscriptionRequestT = Model::GetDataLakeExceptionSubscriptionRequest>
        void GetDataLakeExceptionSubscriptionAsync(const GetDataLakeExceptionSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetDataLakeExceptionSubscriptionRequestT& request = {}) const
        {
            return SubmitAsync(&SecurityLakeClient::GetDataLakeExceptionSubscription, request, handler, context);
        }
 
        virtual Model::GetDataLakeOrganizationConfigurationOutcome GetDataLakeOrganizationConfiguration(const Model::GetDataLakeOrganizationConfigurationRequest& request = {}) const;
 
        template<typename GetDataLakeOrganizationConfigurationRequestT = Model::GetDataLakeOrganizationConfigurationRequest>
        Model::GetDataLakeOrganizationConfigurationOutcomeCallable GetDataLakeOrganizationConfigurationCallable(const GetDataLakeOrganizationConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&SecurityLakeClient::GetDataLakeOrganizationConfiguration, request);
        }
 
        template<typename GetDataLakeOrganizationConfigurationRequestT = Model::GetDataLakeOrganizationConfigurationRequest>
        void GetDataLakeOrganizationConfigurationAsync(const GetDataLakeOrganizationConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetDataLakeOrganizationConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&SecurityLakeClient::GetDataLakeOrganizationConfiguration, request, handler, context);
        }
 
        virtual Model::GetDataLakeSourcesOutcome GetDataLakeSources(const Model::GetDataLakeSourcesRequest& request = {}) const;
 
        template<typename GetDataLakeSourcesRequestT = Model::GetDataLakeSourcesRequest>
        Model::GetDataLakeSourcesOutcomeCallable GetDataLakeSourcesCallable(const GetDataLakeSourcesRequestT& request = {}) const
        {
            return SubmitCallable(&SecurityLakeClient::GetDataLakeSources, request);
        }
 
        template<typename GetDataLakeSourcesRequestT = Model::GetDataLakeSourcesRequest>
        void GetDataLakeSourcesAsync(const GetDataLakeSourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetDataLakeSourcesRequestT& request = {}) const
        {
            return SubmitAsync(&SecurityLakeClient::GetDataLakeSources, request, handler, context);
        }
 
        virtual Model::GetSubscriberOutcome GetSubscriber(const Model::GetSubscriberRequest& request) const;
 
        template<typename GetSubscriberRequestT = Model::GetSubscriberRequest>
        Model::GetSubscriberOutcomeCallable GetSubscriberCallable(const GetSubscriberRequestT& request) const
        {
            return SubmitCallable(&SecurityLakeClient::GetSubscriber, request);
        }
 
        template<typename GetSubscriberRequestT = Model::GetSubscriberRequest>
        void GetSubscriberAsync(const GetSubscriberRequestT& request, const GetSubscriberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SecurityLakeClient::GetSubscriber, request, handler, context);
        }
 
        virtual Model::ListDataLakeExceptionsOutcome ListDataLakeExceptions(const Model::ListDataLakeExceptionsRequest& request = {}) const;
 
        template<typename ListDataLakeExceptionsRequestT = Model::ListDataLakeExceptionsRequest>
        Model::ListDataLakeExceptionsOutcomeCallable ListDataLakeExceptionsCallable(const ListDataLakeExceptionsRequestT& request = {}) const
        {
            return SubmitCallable(&SecurityLakeClient::ListDataLakeExceptions, request);
        }
 
        template<typename ListDataLakeExceptionsRequestT = Model::ListDataLakeExceptionsRequest>
        void ListDataLakeExceptionsAsync(const ListDataLakeExceptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDataLakeExceptionsRequestT& request = {}) const
        {
            return SubmitAsync(&SecurityLakeClient::ListDataLakeExceptions, request, handler, context);
        }
 
        virtual Model::ListDataLakesOutcome ListDataLakes(const Model::ListDataLakesRequest& request = {}) const;
 
        template<typename ListDataLakesRequestT = Model::ListDataLakesRequest>
        Model::ListDataLakesOutcomeCallable ListDataLakesCallable(const ListDataLakesRequestT& request = {}) const
        {
            return SubmitCallable(&SecurityLakeClient::ListDataLakes, request);
        }
 
        template<typename ListDataLakesRequestT = Model::ListDataLakesRequest>
        void ListDataLakesAsync(const ListDataLakesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDataLakesRequestT& request = {}) const
        {
            return SubmitAsync(&SecurityLakeClient::ListDataLakes, request, handler, context);
        }
 
        virtual Model::ListLogSourcesOutcome ListLogSources(const Model::ListLogSourcesRequest& request = {}) const;
 
        template<typename ListLogSourcesRequestT = Model::ListLogSourcesRequest>
        Model::ListLogSourcesOutcomeCallable ListLogSourcesCallable(const ListLogSourcesRequestT& request = {}) const
        {
            return SubmitCallable(&SecurityLakeClient::ListLogSources, request);
        }
 
        template<typename ListLogSourcesRequestT = Model::ListLogSourcesRequest>
        void ListLogSourcesAsync(const ListLogSourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListLogSourcesRequestT& request = {}) const
        {
            return SubmitAsync(&SecurityLakeClient::ListLogSources, request, handler, context);
        }
 
        virtual Model::ListSubscribersOutcome ListSubscribers(const Model::ListSubscribersRequest& request = {}) const;
 
        template<typename ListSubscribersRequestT = Model::ListSubscribersRequest>
        Model::ListSubscribersOutcomeCallable ListSubscribersCallable(const ListSubscribersRequestT& request = {}) const
        {
            return SubmitCallable(&SecurityLakeClient::ListSubscribers, request);
        }
 
        template<typename ListSubscribersRequestT = Model::ListSubscribersRequest>
        void ListSubscribersAsync(const ListSubscribersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSubscribersRequestT& request = {}) const
        {
            return SubmitAsync(&SecurityLakeClient::ListSubscribers, 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(&SecurityLakeClient::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(&SecurityLakeClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::RegisterDataLakeDelegatedAdministratorOutcome RegisterDataLakeDelegatedAdministrator(const Model::RegisterDataLakeDelegatedAdministratorRequest& request) const;
 
        template<typename RegisterDataLakeDelegatedAdministratorRequestT = Model::RegisterDataLakeDelegatedAdministratorRequest>
        Model::RegisterDataLakeDelegatedAdministratorOutcomeCallable RegisterDataLakeDelegatedAdministratorCallable(const RegisterDataLakeDelegatedAdministratorRequestT& request) const
        {
            return SubmitCallable(&SecurityLakeClient::RegisterDataLakeDelegatedAdministrator, request);
        }
 
        template<typename RegisterDataLakeDelegatedAdministratorRequestT = Model::RegisterDataLakeDelegatedAdministratorRequest>
        void RegisterDataLakeDelegatedAdministratorAsync(const RegisterDataLakeDelegatedAdministratorRequestT& request, const RegisterDataLakeDelegatedAdministratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SecurityLakeClient::RegisterDataLakeDelegatedAdministrator, 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(&SecurityLakeClient::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(&SecurityLakeClient::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(&SecurityLakeClient::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(&SecurityLakeClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateDataLakeOutcome UpdateDataLake(const Model::UpdateDataLakeRequest& request) const;
 
        template<typename UpdateDataLakeRequestT = Model::UpdateDataLakeRequest>
        Model::UpdateDataLakeOutcomeCallable UpdateDataLakeCallable(const UpdateDataLakeRequestT& request) const
        {
            return SubmitCallable(&SecurityLakeClient::UpdateDataLake, request);
        }
 
        template<typename UpdateDataLakeRequestT = Model::UpdateDataLakeRequest>
        void UpdateDataLakeAsync(const UpdateDataLakeRequestT& request, const UpdateDataLakeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SecurityLakeClient::UpdateDataLake, request, handler, context);
        }
 
        virtual Model::UpdateDataLakeExceptionSubscriptionOutcome UpdateDataLakeExceptionSubscription(const Model::UpdateDataLakeExceptionSubscriptionRequest& request) const;
 
        template<typename UpdateDataLakeExceptionSubscriptionRequestT = Model::UpdateDataLakeExceptionSubscriptionRequest>
        Model::UpdateDataLakeExceptionSubscriptionOutcomeCallable UpdateDataLakeExceptionSubscriptionCallable(const UpdateDataLakeExceptionSubscriptionRequestT& request) const
        {
            return SubmitCallable(&SecurityLakeClient::UpdateDataLakeExceptionSubscription, request);
        }
 
        template<typename UpdateDataLakeExceptionSubscriptionRequestT = Model::UpdateDataLakeExceptionSubscriptionRequest>
        void UpdateDataLakeExceptionSubscriptionAsync(const UpdateDataLakeExceptionSubscriptionRequestT& request, const UpdateDataLakeExceptionSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SecurityLakeClient::UpdateDataLakeExceptionSubscription, request, handler, context);
        }
 
        virtual Model::UpdateSubscriberOutcome UpdateSubscriber(const Model::UpdateSubscriberRequest& request) const;
 
        template<typename UpdateSubscriberRequestT = Model::UpdateSubscriberRequest>
        Model::UpdateSubscriberOutcomeCallable UpdateSubscriberCallable(const UpdateSubscriberRequestT& request) const
        {
            return SubmitCallable(&SecurityLakeClient::UpdateSubscriber, request);
        }
 
        template<typename UpdateSubscriberRequestT = Model::UpdateSubscriberRequest>
        void UpdateSubscriberAsync(const UpdateSubscriberRequestT& request, const UpdateSubscriberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SecurityLakeClient::UpdateSubscriber, request, handler, context);
        }
 
        virtual Model::UpdateSubscriberNotificationOutcome UpdateSubscriberNotification(const Model::UpdateSubscriberNotificationRequest& request) const;
 
        template<typename UpdateSubscriberNotificationRequestT = Model::UpdateSubscriberNotificationRequest>
        Model::UpdateSubscriberNotificationOutcomeCallable UpdateSubscriberNotificationCallable(const UpdateSubscriberNotificationRequestT& request) const
        {
            return SubmitCallable(&SecurityLakeClient::UpdateSubscriberNotification, request);
        }
 
        template<typename UpdateSubscriberNotificationRequestT = Model::UpdateSubscriberNotificationRequest>
        void UpdateSubscriberNotificationAsync(const UpdateSubscriberNotificationRequestT& request, const UpdateSubscriberNotificationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SecurityLakeClient::UpdateSubscriberNotification, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<SecurityLakeEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<SecurityLakeClient>;
      void init(const SecurityLakeClientConfiguration& clientConfiguration);
 
      SecurityLakeClientConfiguration m_clientConfiguration;
      std::shared_ptr<SecurityLakeEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace SecurityLake
} // namespace Aws