SecurityLakeClient.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/securitylake/SecurityLakePaginationBase.h>
#include <aws/securitylake/SecurityLakeServiceClientModel.h>
#include <aws/securitylake/SecurityLakeWaiter.h>
#include <aws/securitylake/SecurityLake_EXPORTS.h>
 
namespace Aws {
namespace SecurityLake {
class AWS_SECURITYLAKE_API SecurityLakeClient : public Aws::Client::AWSJsonClient,
                                                public Aws::Client::ClientWithAsyncTemplateMethods<SecurityLakeClient>,
                                                public SecurityLakePaginationBase<SecurityLakeClient>,
                                                public SecurityLakeWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<SecurityLakeEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<SecurityLakeClient>;
  void init(const SecurityLakeClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, SecurityLakeError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  SecurityLakeClientConfiguration m_clientConfiguration;
  std::shared_ptr<SecurityLakeEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace SecurityLake
}  // namespace Aws