CloudTrailClient.h

 
#pragma once
#include <aws/cloudtrail/CloudTrailPaginationBase.h>
#include <aws/cloudtrail/CloudTrailServiceClientModel.h>
#include <aws/cloudtrail/CloudTrailWaiter.h>
#include <aws/cloudtrail/CloudTrail_EXPORTS.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
 
namespace Aws {
namespace CloudTrail {
class AWS_CLOUDTRAIL_API CloudTrailClient : public Aws::Client::AWSJsonClient,
                                            public Aws::Client::ClientWithAsyncTemplateMethods<CloudTrailClient>,
                                            public CloudTrailPaginationBase<CloudTrailClient>,
                                            public CloudTrailWaiter<CloudTrailClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef CloudTrailClientConfiguration ClientConfigurationType;
  typedef CloudTrailEndpointProvider EndpointProviderType;
 
  CloudTrailClient(
      const Aws::CloudTrail::CloudTrailClientConfiguration& clientConfiguration = Aws::CloudTrail::CloudTrailClientConfiguration(),
      std::shared_ptr<CloudTrailEndpointProviderBase> endpointProvider = nullptr);
 
  CloudTrailClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<CloudTrailEndpointProviderBase> endpointProvider = nullptr,
      const Aws::CloudTrail::CloudTrailClientConfiguration& clientConfiguration = Aws::CloudTrail::CloudTrailClientConfiguration());
 
  CloudTrailClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<CloudTrailEndpointProviderBase> endpointProvider = nullptr,
      const Aws::CloudTrail::CloudTrailClientConfiguration& clientConfiguration = Aws::CloudTrail::CloudTrailClientConfiguration());
 
  /* Legacy constructors due deprecation */
  CloudTrailClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CloudTrailClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CloudTrailClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                   const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~CloudTrailClient();
 
  virtual Model::AddTagsOutcome AddTags(const Model::AddTagsRequest& request) const;
 
  template <typename AddTagsRequestT = Model::AddTagsRequest>
  Model::AddTagsOutcomeCallable AddTagsCallable(const AddTagsRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::AddTags, request);
  }
 
  template <typename AddTagsRequestT = Model::AddTagsRequest>
  void AddTagsAsync(const AddTagsRequestT& request, const AddTagsResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::AddTags, request, handler, context);
  }
 
  virtual Model::CancelQueryOutcome CancelQuery(const Model::CancelQueryRequest& request) const;
 
  template <typename CancelQueryRequestT = Model::CancelQueryRequest>
  Model::CancelQueryOutcomeCallable CancelQueryCallable(const CancelQueryRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::CancelQuery, request);
  }
 
  template <typename CancelQueryRequestT = Model::CancelQueryRequest>
  void CancelQueryAsync(const CancelQueryRequestT& request, const CancelQueryResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::CancelQuery, request, handler, context);
  }
 
  virtual Model::CreateChannelOutcome CreateChannel(const Model::CreateChannelRequest& request) const;
 
  template <typename CreateChannelRequestT = Model::CreateChannelRequest>
  Model::CreateChannelOutcomeCallable CreateChannelCallable(const CreateChannelRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::CreateChannel, request);
  }
 
  template <typename CreateChannelRequestT = Model::CreateChannelRequest>
  void CreateChannelAsync(const CreateChannelRequestT& request, const CreateChannelResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::CreateChannel, request, handler, context);
  }
 
  virtual Model::CreateDashboardOutcome CreateDashboard(const Model::CreateDashboardRequest& request) const;
 
  template <typename CreateDashboardRequestT = Model::CreateDashboardRequest>
  Model::CreateDashboardOutcomeCallable CreateDashboardCallable(const CreateDashboardRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::CreateDashboard, request);
  }
 
  template <typename CreateDashboardRequestT = Model::CreateDashboardRequest>
  void CreateDashboardAsync(const CreateDashboardRequestT& request, const CreateDashboardResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::CreateDashboard, request, handler, context);
  }
 
  virtual Model::CreateEventDataStoreOutcome CreateEventDataStore(const Model::CreateEventDataStoreRequest& request) const;
 
  template <typename CreateEventDataStoreRequestT = Model::CreateEventDataStoreRequest>
  Model::CreateEventDataStoreOutcomeCallable CreateEventDataStoreCallable(const CreateEventDataStoreRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::CreateEventDataStore, request);
  }
 
  template <typename CreateEventDataStoreRequestT = Model::CreateEventDataStoreRequest>
  void CreateEventDataStoreAsync(const CreateEventDataStoreRequestT& request, const CreateEventDataStoreResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::CreateEventDataStore, request, handler, context);
  }
 
  virtual Model::CreateTrailOutcome CreateTrail(const Model::CreateTrailRequest& request) const;
 
  template <typename CreateTrailRequestT = Model::CreateTrailRequest>
  Model::CreateTrailOutcomeCallable CreateTrailCallable(const CreateTrailRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::CreateTrail, request);
  }
 
  template <typename CreateTrailRequestT = Model::CreateTrailRequest>
  void CreateTrailAsync(const CreateTrailRequestT& request, const CreateTrailResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::CreateTrail, request, handler, context);
  }
 
  virtual Model::DeleteChannelOutcome DeleteChannel(const Model::DeleteChannelRequest& request) const;
 
  template <typename DeleteChannelRequestT = Model::DeleteChannelRequest>
  Model::DeleteChannelOutcomeCallable DeleteChannelCallable(const DeleteChannelRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::DeleteChannel, request);
  }
 
  template <typename DeleteChannelRequestT = Model::DeleteChannelRequest>
  void DeleteChannelAsync(const DeleteChannelRequestT& request, const DeleteChannelResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::DeleteChannel, request, handler, context);
  }
 
  virtual Model::DeleteDashboardOutcome DeleteDashboard(const Model::DeleteDashboardRequest& request) const;
 
  template <typename DeleteDashboardRequestT = Model::DeleteDashboardRequest>
  Model::DeleteDashboardOutcomeCallable DeleteDashboardCallable(const DeleteDashboardRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::DeleteDashboard, request);
  }
 
  template <typename DeleteDashboardRequestT = Model::DeleteDashboardRequest>
  void DeleteDashboardAsync(const DeleteDashboardRequestT& request, const DeleteDashboardResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::DeleteDashboard, request, handler, context);
  }
 
  virtual Model::DeleteEventDataStoreOutcome DeleteEventDataStore(const Model::DeleteEventDataStoreRequest& request) const;
 
  template <typename DeleteEventDataStoreRequestT = Model::DeleteEventDataStoreRequest>
  Model::DeleteEventDataStoreOutcomeCallable DeleteEventDataStoreCallable(const DeleteEventDataStoreRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::DeleteEventDataStore, request);
  }
 
  template <typename DeleteEventDataStoreRequestT = Model::DeleteEventDataStoreRequest>
  void DeleteEventDataStoreAsync(const DeleteEventDataStoreRequestT& request, const DeleteEventDataStoreResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::DeleteEventDataStore, request, handler, context);
  }
 
  virtual Model::DeleteResourcePolicyOutcome DeleteResourcePolicy(const Model::DeleteResourcePolicyRequest& request) const;
 
  template <typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
  Model::DeleteResourcePolicyOutcomeCallable DeleteResourcePolicyCallable(const DeleteResourcePolicyRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::DeleteResourcePolicy, request);
  }
 
  template <typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
  void DeleteResourcePolicyAsync(const DeleteResourcePolicyRequestT& request, const DeleteResourcePolicyResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::DeleteResourcePolicy, request, handler, context);
  }
 
  virtual Model::DeleteTrailOutcome DeleteTrail(const Model::DeleteTrailRequest& request) const;
 
  template <typename DeleteTrailRequestT = Model::DeleteTrailRequest>
  Model::DeleteTrailOutcomeCallable DeleteTrailCallable(const DeleteTrailRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::DeleteTrail, request);
  }
 
  template <typename DeleteTrailRequestT = Model::DeleteTrailRequest>
  void DeleteTrailAsync(const DeleteTrailRequestT& request, const DeleteTrailResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::DeleteTrail, request, handler, context);
  }
 
  virtual Model::DeregisterOrganizationDelegatedAdminOutcome DeregisterOrganizationDelegatedAdmin(
      const Model::DeregisterOrganizationDelegatedAdminRequest& request) const;
 
  template <typename DeregisterOrganizationDelegatedAdminRequestT = Model::DeregisterOrganizationDelegatedAdminRequest>
  Model::DeregisterOrganizationDelegatedAdminOutcomeCallable DeregisterOrganizationDelegatedAdminCallable(
      const DeregisterOrganizationDelegatedAdminRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::DeregisterOrganizationDelegatedAdmin, request);
  }
 
  template <typename DeregisterOrganizationDelegatedAdminRequestT = Model::DeregisterOrganizationDelegatedAdminRequest>
  void DeregisterOrganizationDelegatedAdminAsync(const DeregisterOrganizationDelegatedAdminRequestT& request,
                                                 const DeregisterOrganizationDelegatedAdminResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::DeregisterOrganizationDelegatedAdmin, request, handler, context);
  }
 
  virtual Model::DescribeQueryOutcome DescribeQuery(const Model::DescribeQueryRequest& request = {}) const;
 
  template <typename DescribeQueryRequestT = Model::DescribeQueryRequest>
  Model::DescribeQueryOutcomeCallable DescribeQueryCallable(const DescribeQueryRequestT& request = {}) const {
    return SubmitCallable(&CloudTrailClient::DescribeQuery, request);
  }
 
  template <typename DescribeQueryRequestT = Model::DescribeQueryRequest>
  void DescribeQueryAsync(const DescribeQueryResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const DescribeQueryRequestT& request = {}) const {
    return SubmitAsync(&CloudTrailClient::DescribeQuery, request, handler, context);
  }
 
  virtual Model::DescribeTrailsOutcome DescribeTrails(const Model::DescribeTrailsRequest& request = {}) const;
 
  template <typename DescribeTrailsRequestT = Model::DescribeTrailsRequest>
  Model::DescribeTrailsOutcomeCallable DescribeTrailsCallable(const DescribeTrailsRequestT& request = {}) const {
    return SubmitCallable(&CloudTrailClient::DescribeTrails, request);
  }
 
  template <typename DescribeTrailsRequestT = Model::DescribeTrailsRequest>
  void DescribeTrailsAsync(const DescribeTrailsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const DescribeTrailsRequestT& request = {}) const {
    return SubmitAsync(&CloudTrailClient::DescribeTrails, request, handler, context);
  }
 
  virtual Model::DisableFederationOutcome DisableFederation(const Model::DisableFederationRequest& request) const;
 
  template <typename DisableFederationRequestT = Model::DisableFederationRequest>
  Model::DisableFederationOutcomeCallable DisableFederationCallable(const DisableFederationRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::DisableFederation, request);
  }
 
  template <typename DisableFederationRequestT = Model::DisableFederationRequest>
  void DisableFederationAsync(const DisableFederationRequestT& request, const DisableFederationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::DisableFederation, request, handler, context);
  }
 
  virtual Model::EnableFederationOutcome EnableFederation(const Model::EnableFederationRequest& request) const;
 
  template <typename EnableFederationRequestT = Model::EnableFederationRequest>
  Model::EnableFederationOutcomeCallable EnableFederationCallable(const EnableFederationRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::EnableFederation, request);
  }
 
  template <typename EnableFederationRequestT = Model::EnableFederationRequest>
  void EnableFederationAsync(const EnableFederationRequestT& request, const EnableFederationResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::EnableFederation, request, handler, context);
  }
 
  virtual Model::GenerateQueryOutcome GenerateQuery(const Model::GenerateQueryRequest& request) const;
 
  template <typename GenerateQueryRequestT = Model::GenerateQueryRequest>
  Model::GenerateQueryOutcomeCallable GenerateQueryCallable(const GenerateQueryRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::GenerateQuery, request);
  }
 
  template <typename GenerateQueryRequestT = Model::GenerateQueryRequest>
  void GenerateQueryAsync(const GenerateQueryRequestT& request, const GenerateQueryResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::GenerateQuery, request, handler, context);
  }
 
  virtual Model::GetChannelOutcome GetChannel(const Model::GetChannelRequest& request) const;
 
  template <typename GetChannelRequestT = Model::GetChannelRequest>
  Model::GetChannelOutcomeCallable GetChannelCallable(const GetChannelRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::GetChannel, request);
  }
 
  template <typename GetChannelRequestT = Model::GetChannelRequest>
  void GetChannelAsync(const GetChannelRequestT& request, const GetChannelResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::GetChannel, request, handler, context);
  }
 
  virtual Model::GetDashboardOutcome GetDashboard(const Model::GetDashboardRequest& request) const;
 
  template <typename GetDashboardRequestT = Model::GetDashboardRequest>
  Model::GetDashboardOutcomeCallable GetDashboardCallable(const GetDashboardRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::GetDashboard, request);
  }
 
  template <typename GetDashboardRequestT = Model::GetDashboardRequest>
  void GetDashboardAsync(const GetDashboardRequestT& request, const GetDashboardResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::GetDashboard, request, handler, context);
  }
 
  virtual Model::GetEventConfigurationOutcome GetEventConfiguration(const Model::GetEventConfigurationRequest& request = {}) const;
 
  template <typename GetEventConfigurationRequestT = Model::GetEventConfigurationRequest>
  Model::GetEventConfigurationOutcomeCallable GetEventConfigurationCallable(const GetEventConfigurationRequestT& request = {}) const {
    return SubmitCallable(&CloudTrailClient::GetEventConfiguration, request);
  }
 
  template <typename GetEventConfigurationRequestT = Model::GetEventConfigurationRequest>
  void GetEventConfigurationAsync(const GetEventConfigurationResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const GetEventConfigurationRequestT& request = {}) const {
    return SubmitAsync(&CloudTrailClient::GetEventConfiguration, request, handler, context);
  }
 
  virtual Model::GetEventDataStoreOutcome GetEventDataStore(const Model::GetEventDataStoreRequest& request) const;
 
  template <typename GetEventDataStoreRequestT = Model::GetEventDataStoreRequest>
  Model::GetEventDataStoreOutcomeCallable GetEventDataStoreCallable(const GetEventDataStoreRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::GetEventDataStore, request);
  }
 
  template <typename GetEventDataStoreRequestT = Model::GetEventDataStoreRequest>
  void GetEventDataStoreAsync(const GetEventDataStoreRequestT& request, const GetEventDataStoreResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::GetEventDataStore, request, handler, context);
  }
 
  virtual Model::GetEventSelectorsOutcome GetEventSelectors(const Model::GetEventSelectorsRequest& request) const;
 
  template <typename GetEventSelectorsRequestT = Model::GetEventSelectorsRequest>
  Model::GetEventSelectorsOutcomeCallable GetEventSelectorsCallable(const GetEventSelectorsRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::GetEventSelectors, request);
  }
 
  template <typename GetEventSelectorsRequestT = Model::GetEventSelectorsRequest>
  void GetEventSelectorsAsync(const GetEventSelectorsRequestT& request, const GetEventSelectorsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::GetEventSelectors, request, handler, context);
  }
 
  virtual Model::GetImportOutcome GetImport(const Model::GetImportRequest& request) const;
 
  template <typename GetImportRequestT = Model::GetImportRequest>
  Model::GetImportOutcomeCallable GetImportCallable(const GetImportRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::GetImport, request);
  }
 
  template <typename GetImportRequestT = Model::GetImportRequest>
  void GetImportAsync(const GetImportRequestT& request, const GetImportResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::GetImport, request, handler, context);
  }
 
  virtual Model::GetInsightSelectorsOutcome GetInsightSelectors(const Model::GetInsightSelectorsRequest& request = {}) const;
 
  template <typename GetInsightSelectorsRequestT = Model::GetInsightSelectorsRequest>
  Model::GetInsightSelectorsOutcomeCallable GetInsightSelectorsCallable(const GetInsightSelectorsRequestT& request = {}) const {
    return SubmitCallable(&CloudTrailClient::GetInsightSelectors, request);
  }
 
  template <typename GetInsightSelectorsRequestT = Model::GetInsightSelectorsRequest>
  void GetInsightSelectorsAsync(const GetInsightSelectorsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const GetInsightSelectorsRequestT& request = {}) const {
    return SubmitAsync(&CloudTrailClient::GetInsightSelectors, request, handler, context);
  }
 
  virtual Model::GetQueryResultsOutcome GetQueryResults(const Model::GetQueryResultsRequest& request) const;
 
  template <typename GetQueryResultsRequestT = Model::GetQueryResultsRequest>
  Model::GetQueryResultsOutcomeCallable GetQueryResultsCallable(const GetQueryResultsRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::GetQueryResults, request);
  }
 
  template <typename GetQueryResultsRequestT = Model::GetQueryResultsRequest>
  void GetQueryResultsAsync(const GetQueryResultsRequestT& request, const GetQueryResultsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::GetQueryResults, request, handler, context);
  }
 
  virtual Model::GetResourcePolicyOutcome GetResourcePolicy(const Model::GetResourcePolicyRequest& request) const;
 
  template <typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
  Model::GetResourcePolicyOutcomeCallable GetResourcePolicyCallable(const GetResourcePolicyRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::GetResourcePolicy, request);
  }
 
  template <typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
  void GetResourcePolicyAsync(const GetResourcePolicyRequestT& request, const GetResourcePolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::GetResourcePolicy, request, handler, context);
  }
 
  virtual Model::GetTrailOutcome GetTrail(const Model::GetTrailRequest& request) const;
 
  template <typename GetTrailRequestT = Model::GetTrailRequest>
  Model::GetTrailOutcomeCallable GetTrailCallable(const GetTrailRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::GetTrail, request);
  }
 
  template <typename GetTrailRequestT = Model::GetTrailRequest>
  void GetTrailAsync(const GetTrailRequestT& request, const GetTrailResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::GetTrail, request, handler, context);
  }
 
  virtual Model::GetTrailStatusOutcome GetTrailStatus(const Model::GetTrailStatusRequest& request) const;
 
  template <typename GetTrailStatusRequestT = Model::GetTrailStatusRequest>
  Model::GetTrailStatusOutcomeCallable GetTrailStatusCallable(const GetTrailStatusRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::GetTrailStatus, request);
  }
 
  template <typename GetTrailStatusRequestT = Model::GetTrailStatusRequest>
  void GetTrailStatusAsync(const GetTrailStatusRequestT& request, const GetTrailStatusResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::GetTrailStatus, request, handler, context);
  }
 
  virtual Model::ListChannelsOutcome ListChannels(const Model::ListChannelsRequest& request = {}) const;
 
  template <typename ListChannelsRequestT = Model::ListChannelsRequest>
  Model::ListChannelsOutcomeCallable ListChannelsCallable(const ListChannelsRequestT& request = {}) const {
    return SubmitCallable(&CloudTrailClient::ListChannels, request);
  }
 
  template <typename ListChannelsRequestT = Model::ListChannelsRequest>
  void ListChannelsAsync(const ListChannelsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListChannelsRequestT& request = {}) const {
    return SubmitAsync(&CloudTrailClient::ListChannels, request, handler, context);
  }
 
  virtual Model::ListDashboardsOutcome ListDashboards(const Model::ListDashboardsRequest& request = {}) const;
 
  template <typename ListDashboardsRequestT = Model::ListDashboardsRequest>
  Model::ListDashboardsOutcomeCallable ListDashboardsCallable(const ListDashboardsRequestT& request = {}) const {
    return SubmitCallable(&CloudTrailClient::ListDashboards, request);
  }
 
  template <typename ListDashboardsRequestT = Model::ListDashboardsRequest>
  void ListDashboardsAsync(const ListDashboardsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListDashboardsRequestT& request = {}) const {
    return SubmitAsync(&CloudTrailClient::ListDashboards, request, handler, context);
  }
 
  virtual Model::ListEventDataStoresOutcome ListEventDataStores(const Model::ListEventDataStoresRequest& request = {}) const;
 
  template <typename ListEventDataStoresRequestT = Model::ListEventDataStoresRequest>
  Model::ListEventDataStoresOutcomeCallable ListEventDataStoresCallable(const ListEventDataStoresRequestT& request = {}) const {
    return SubmitCallable(&CloudTrailClient::ListEventDataStores, request);
  }
 
  template <typename ListEventDataStoresRequestT = Model::ListEventDataStoresRequest>
  void ListEventDataStoresAsync(const ListEventDataStoresResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListEventDataStoresRequestT& request = {}) const {
    return SubmitAsync(&CloudTrailClient::ListEventDataStores, request, handler, context);
  }
 
  virtual Model::ListImportFailuresOutcome ListImportFailures(const Model::ListImportFailuresRequest& request) const;
 
  template <typename ListImportFailuresRequestT = Model::ListImportFailuresRequest>
  Model::ListImportFailuresOutcomeCallable ListImportFailuresCallable(const ListImportFailuresRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::ListImportFailures, request);
  }
 
  template <typename ListImportFailuresRequestT = Model::ListImportFailuresRequest>
  void ListImportFailuresAsync(const ListImportFailuresRequestT& request, const ListImportFailuresResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::ListImportFailures, request, handler, context);
  }
 
  virtual Model::ListImportsOutcome ListImports(const Model::ListImportsRequest& request = {}) const;
 
  template <typename ListImportsRequestT = Model::ListImportsRequest>
  Model::ListImportsOutcomeCallable ListImportsCallable(const ListImportsRequestT& request = {}) const {
    return SubmitCallable(&CloudTrailClient::ListImports, request);
  }
 
  template <typename ListImportsRequestT = Model::ListImportsRequest>
  void ListImportsAsync(const ListImportsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListImportsRequestT& request = {}) const {
    return SubmitAsync(&CloudTrailClient::ListImports, request, handler, context);
  }
 
  virtual Model::ListInsightsDataOutcome ListInsightsData(const Model::ListInsightsDataRequest& request) const;
 
  template <typename ListInsightsDataRequestT = Model::ListInsightsDataRequest>
  Model::ListInsightsDataOutcomeCallable ListInsightsDataCallable(const ListInsightsDataRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::ListInsightsData, request);
  }
 
  template <typename ListInsightsDataRequestT = Model::ListInsightsDataRequest>
  void ListInsightsDataAsync(const ListInsightsDataRequestT& request, const ListInsightsDataResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::ListInsightsData, request, handler, context);
  }
 
  virtual Model::ListInsightsMetricDataOutcome ListInsightsMetricData(const Model::ListInsightsMetricDataRequest& request) const;
 
  template <typename ListInsightsMetricDataRequestT = Model::ListInsightsMetricDataRequest>
  Model::ListInsightsMetricDataOutcomeCallable ListInsightsMetricDataCallable(const ListInsightsMetricDataRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::ListInsightsMetricData, request);
  }
 
  template <typename ListInsightsMetricDataRequestT = Model::ListInsightsMetricDataRequest>
  void ListInsightsMetricDataAsync(const ListInsightsMetricDataRequestT& request,
                                   const ListInsightsMetricDataResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::ListInsightsMetricData, request, handler, context);
  }
 
  virtual Model::ListPublicKeysOutcome ListPublicKeys(const Model::ListPublicKeysRequest& request = {}) const;
 
  template <typename ListPublicKeysRequestT = Model::ListPublicKeysRequest>
  Model::ListPublicKeysOutcomeCallable ListPublicKeysCallable(const ListPublicKeysRequestT& request = {}) const {
    return SubmitCallable(&CloudTrailClient::ListPublicKeys, request);
  }
 
  template <typename ListPublicKeysRequestT = Model::ListPublicKeysRequest>
  void ListPublicKeysAsync(const ListPublicKeysResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListPublicKeysRequestT& request = {}) const {
    return SubmitAsync(&CloudTrailClient::ListPublicKeys, request, handler, context);
  }
 
  virtual Model::ListQueriesOutcome ListQueries(const Model::ListQueriesRequest& request) const;
 
  template <typename ListQueriesRequestT = Model::ListQueriesRequest>
  Model::ListQueriesOutcomeCallable ListQueriesCallable(const ListQueriesRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::ListQueries, request);
  }
 
  template <typename ListQueriesRequestT = Model::ListQueriesRequest>
  void ListQueriesAsync(const ListQueriesRequestT& request, const ListQueriesResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::ListQueries, request, handler, context);
  }
 
  virtual Model::ListTagsOutcome ListTags(const Model::ListTagsRequest& request) const;
 
  template <typename ListTagsRequestT = Model::ListTagsRequest>
  Model::ListTagsOutcomeCallable ListTagsCallable(const ListTagsRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::ListTags, request);
  }
 
  template <typename ListTagsRequestT = Model::ListTagsRequest>
  void ListTagsAsync(const ListTagsRequestT& request, const ListTagsResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::ListTags, request, handler, context);
  }
 
  virtual Model::ListTrailsOutcome ListTrails(const Model::ListTrailsRequest& request = {}) const;
 
  template <typename ListTrailsRequestT = Model::ListTrailsRequest>
  Model::ListTrailsOutcomeCallable ListTrailsCallable(const ListTrailsRequestT& request = {}) const {
    return SubmitCallable(&CloudTrailClient::ListTrails, request);
  }
 
  template <typename ListTrailsRequestT = Model::ListTrailsRequest>
  void ListTrailsAsync(const ListTrailsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const ListTrailsRequestT& request = {}) const {
    return SubmitAsync(&CloudTrailClient::ListTrails, request, handler, context);
  }
 
  virtual Model::LookupEventsOutcome LookupEvents(const Model::LookupEventsRequest& request = {}) const;
 
  template <typename LookupEventsRequestT = Model::LookupEventsRequest>
  Model::LookupEventsOutcomeCallable LookupEventsCallable(const LookupEventsRequestT& request = {}) const {
    return SubmitCallable(&CloudTrailClient::LookupEvents, request);
  }
 
  template <typename LookupEventsRequestT = Model::LookupEventsRequest>
  void LookupEventsAsync(const LookupEventsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const LookupEventsRequestT& request = {}) const {
    return SubmitAsync(&CloudTrailClient::LookupEvents, request, handler, context);
  }
 
  virtual Model::PutEventConfigurationOutcome PutEventConfiguration(const Model::PutEventConfigurationRequest& request = {}) const;
 
  template <typename PutEventConfigurationRequestT = Model::PutEventConfigurationRequest>
  Model::PutEventConfigurationOutcomeCallable PutEventConfigurationCallable(const PutEventConfigurationRequestT& request = {}) const {
    return SubmitCallable(&CloudTrailClient::PutEventConfiguration, request);
  }
 
  template <typename PutEventConfigurationRequestT = Model::PutEventConfigurationRequest>
  void PutEventConfigurationAsync(const PutEventConfigurationResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const PutEventConfigurationRequestT& request = {}) const {
    return SubmitAsync(&CloudTrailClient::PutEventConfiguration, request, handler, context);
  }
 
  virtual Model::PutEventSelectorsOutcome PutEventSelectors(const Model::PutEventSelectorsRequest& request) const;
 
  template <typename PutEventSelectorsRequestT = Model::PutEventSelectorsRequest>
  Model::PutEventSelectorsOutcomeCallable PutEventSelectorsCallable(const PutEventSelectorsRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::PutEventSelectors, request);
  }
 
  template <typename PutEventSelectorsRequestT = Model::PutEventSelectorsRequest>
  void PutEventSelectorsAsync(const PutEventSelectorsRequestT& request, const PutEventSelectorsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::PutEventSelectors, request, handler, context);
  }
 
  virtual Model::PutInsightSelectorsOutcome PutInsightSelectors(const Model::PutInsightSelectorsRequest& request) const;
 
  template <typename PutInsightSelectorsRequestT = Model::PutInsightSelectorsRequest>
  Model::PutInsightSelectorsOutcomeCallable PutInsightSelectorsCallable(const PutInsightSelectorsRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::PutInsightSelectors, request);
  }
 
  template <typename PutInsightSelectorsRequestT = Model::PutInsightSelectorsRequest>
  void PutInsightSelectorsAsync(const PutInsightSelectorsRequestT& request, const PutInsightSelectorsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::PutInsightSelectors, request, handler, context);
  }
 
  virtual Model::PutResourcePolicyOutcome PutResourcePolicy(const Model::PutResourcePolicyRequest& request) const;
 
  template <typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
  Model::PutResourcePolicyOutcomeCallable PutResourcePolicyCallable(const PutResourcePolicyRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::PutResourcePolicy, request);
  }
 
  template <typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
  void PutResourcePolicyAsync(const PutResourcePolicyRequestT& request, const PutResourcePolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::PutResourcePolicy, request, handler, context);
  }
 
  virtual Model::RegisterOrganizationDelegatedAdminOutcome RegisterOrganizationDelegatedAdmin(
      const Model::RegisterOrganizationDelegatedAdminRequest& request) const;
 
  template <typename RegisterOrganizationDelegatedAdminRequestT = Model::RegisterOrganizationDelegatedAdminRequest>
  Model::RegisterOrganizationDelegatedAdminOutcomeCallable RegisterOrganizationDelegatedAdminCallable(
      const RegisterOrganizationDelegatedAdminRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::RegisterOrganizationDelegatedAdmin, request);
  }
 
  template <typename RegisterOrganizationDelegatedAdminRequestT = Model::RegisterOrganizationDelegatedAdminRequest>
  void RegisterOrganizationDelegatedAdminAsync(const RegisterOrganizationDelegatedAdminRequestT& request,
                                               const RegisterOrganizationDelegatedAdminResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::RegisterOrganizationDelegatedAdmin, request, handler, context);
  }
 
  virtual Model::RemoveTagsOutcome RemoveTags(const Model::RemoveTagsRequest& request) const;
 
  template <typename RemoveTagsRequestT = Model::RemoveTagsRequest>
  Model::RemoveTagsOutcomeCallable RemoveTagsCallable(const RemoveTagsRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::RemoveTags, request);
  }
 
  template <typename RemoveTagsRequestT = Model::RemoveTagsRequest>
  void RemoveTagsAsync(const RemoveTagsRequestT& request, const RemoveTagsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::RemoveTags, request, handler, context);
  }
 
  virtual Model::RestoreEventDataStoreOutcome RestoreEventDataStore(const Model::RestoreEventDataStoreRequest& request) const;
 
  template <typename RestoreEventDataStoreRequestT = Model::RestoreEventDataStoreRequest>
  Model::RestoreEventDataStoreOutcomeCallable RestoreEventDataStoreCallable(const RestoreEventDataStoreRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::RestoreEventDataStore, request);
  }
 
  template <typename RestoreEventDataStoreRequestT = Model::RestoreEventDataStoreRequest>
  void RestoreEventDataStoreAsync(const RestoreEventDataStoreRequestT& request, const RestoreEventDataStoreResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::RestoreEventDataStore, request, handler, context);
  }
 
  virtual Model::SearchSampleQueriesOutcome SearchSampleQueries(const Model::SearchSampleQueriesRequest& request) const;
 
  template <typename SearchSampleQueriesRequestT = Model::SearchSampleQueriesRequest>
  Model::SearchSampleQueriesOutcomeCallable SearchSampleQueriesCallable(const SearchSampleQueriesRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::SearchSampleQueries, request);
  }
 
  template <typename SearchSampleQueriesRequestT = Model::SearchSampleQueriesRequest>
  void SearchSampleQueriesAsync(const SearchSampleQueriesRequestT& request, const SearchSampleQueriesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::SearchSampleQueries, request, handler, context);
  }
 
  virtual Model::StartDashboardRefreshOutcome StartDashboardRefresh(const Model::StartDashboardRefreshRequest& request) const;
 
  template <typename StartDashboardRefreshRequestT = Model::StartDashboardRefreshRequest>
  Model::StartDashboardRefreshOutcomeCallable StartDashboardRefreshCallable(const StartDashboardRefreshRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::StartDashboardRefresh, request);
  }
 
  template <typename StartDashboardRefreshRequestT = Model::StartDashboardRefreshRequest>
  void StartDashboardRefreshAsync(const StartDashboardRefreshRequestT& request, const StartDashboardRefreshResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::StartDashboardRefresh, request, handler, context);
  }
 
  virtual Model::StartEventDataStoreIngestionOutcome StartEventDataStoreIngestion(
      const Model::StartEventDataStoreIngestionRequest& request) const;
 
  template <typename StartEventDataStoreIngestionRequestT = Model::StartEventDataStoreIngestionRequest>
  Model::StartEventDataStoreIngestionOutcomeCallable StartEventDataStoreIngestionCallable(
      const StartEventDataStoreIngestionRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::StartEventDataStoreIngestion, request);
  }
 
  template <typename StartEventDataStoreIngestionRequestT = Model::StartEventDataStoreIngestionRequest>
  void StartEventDataStoreIngestionAsync(const StartEventDataStoreIngestionRequestT& request,
                                         const StartEventDataStoreIngestionResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::StartEventDataStoreIngestion, request, handler, context);
  }
 
  virtual Model::StartImportOutcome StartImport(const Model::StartImportRequest& request = {}) const;
 
  template <typename StartImportRequestT = Model::StartImportRequest>
  Model::StartImportOutcomeCallable StartImportCallable(const StartImportRequestT& request = {}) const {
    return SubmitCallable(&CloudTrailClient::StartImport, request);
  }
 
  template <typename StartImportRequestT = Model::StartImportRequest>
  void StartImportAsync(const StartImportResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const StartImportRequestT& request = {}) const {
    return SubmitAsync(&CloudTrailClient::StartImport, request, handler, context);
  }
 
  virtual Model::StartLoggingOutcome StartLogging(const Model::StartLoggingRequest& request) const;
 
  template <typename StartLoggingRequestT = Model::StartLoggingRequest>
  Model::StartLoggingOutcomeCallable StartLoggingCallable(const StartLoggingRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::StartLogging, request);
  }
 
  template <typename StartLoggingRequestT = Model::StartLoggingRequest>
  void StartLoggingAsync(const StartLoggingRequestT& request, const StartLoggingResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::StartLogging, request, handler, context);
  }
 
  virtual Model::StartQueryOutcome StartQuery(const Model::StartQueryRequest& request = {}) const;
 
  template <typename StartQueryRequestT = Model::StartQueryRequest>
  Model::StartQueryOutcomeCallable StartQueryCallable(const StartQueryRequestT& request = {}) const {
    return SubmitCallable(&CloudTrailClient::StartQuery, request);
  }
 
  template <typename StartQueryRequestT = Model::StartQueryRequest>
  void StartQueryAsync(const StartQueryResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const StartQueryRequestT& request = {}) const {
    return SubmitAsync(&CloudTrailClient::StartQuery, request, handler, context);
  }
 
  virtual Model::StopEventDataStoreIngestionOutcome StopEventDataStoreIngestion(
      const Model::StopEventDataStoreIngestionRequest& request) const;
 
  template <typename StopEventDataStoreIngestionRequestT = Model::StopEventDataStoreIngestionRequest>
  Model::StopEventDataStoreIngestionOutcomeCallable StopEventDataStoreIngestionCallable(
      const StopEventDataStoreIngestionRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::StopEventDataStoreIngestion, request);
  }
 
  template <typename StopEventDataStoreIngestionRequestT = Model::StopEventDataStoreIngestionRequest>
  void StopEventDataStoreIngestionAsync(const StopEventDataStoreIngestionRequestT& request,
                                        const StopEventDataStoreIngestionResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::StopEventDataStoreIngestion, request, handler, context);
  }
 
  virtual Model::StopImportOutcome StopImport(const Model::StopImportRequest& request) const;
 
  template <typename StopImportRequestT = Model::StopImportRequest>
  Model::StopImportOutcomeCallable StopImportCallable(const StopImportRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::StopImport, request);
  }
 
  template <typename StopImportRequestT = Model::StopImportRequest>
  void StopImportAsync(const StopImportRequestT& request, const StopImportResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::StopImport, request, handler, context);
  }
 
  virtual Model::StopLoggingOutcome StopLogging(const Model::StopLoggingRequest& request) const;
 
  template <typename StopLoggingRequestT = Model::StopLoggingRequest>
  Model::StopLoggingOutcomeCallable StopLoggingCallable(const StopLoggingRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::StopLogging, request);
  }
 
  template <typename StopLoggingRequestT = Model::StopLoggingRequest>
  void StopLoggingAsync(const StopLoggingRequestT& request, const StopLoggingResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::StopLogging, request, handler, context);
  }
 
  virtual Model::UpdateChannelOutcome UpdateChannel(const Model::UpdateChannelRequest& request) const;
 
  template <typename UpdateChannelRequestT = Model::UpdateChannelRequest>
  Model::UpdateChannelOutcomeCallable UpdateChannelCallable(const UpdateChannelRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::UpdateChannel, request);
  }
 
  template <typename UpdateChannelRequestT = Model::UpdateChannelRequest>
  void UpdateChannelAsync(const UpdateChannelRequestT& request, const UpdateChannelResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::UpdateChannel, request, handler, context);
  }
 
  virtual Model::UpdateDashboardOutcome UpdateDashboard(const Model::UpdateDashboardRequest& request) const;
 
  template <typename UpdateDashboardRequestT = Model::UpdateDashboardRequest>
  Model::UpdateDashboardOutcomeCallable UpdateDashboardCallable(const UpdateDashboardRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::UpdateDashboard, request);
  }
 
  template <typename UpdateDashboardRequestT = Model::UpdateDashboardRequest>
  void UpdateDashboardAsync(const UpdateDashboardRequestT& request, const UpdateDashboardResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::UpdateDashboard, request, handler, context);
  }
 
  virtual Model::UpdateEventDataStoreOutcome UpdateEventDataStore(const Model::UpdateEventDataStoreRequest& request) const;
 
  template <typename UpdateEventDataStoreRequestT = Model::UpdateEventDataStoreRequest>
  Model::UpdateEventDataStoreOutcomeCallable UpdateEventDataStoreCallable(const UpdateEventDataStoreRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::UpdateEventDataStore, request);
  }
 
  template <typename UpdateEventDataStoreRequestT = Model::UpdateEventDataStoreRequest>
  void UpdateEventDataStoreAsync(const UpdateEventDataStoreRequestT& request, const UpdateEventDataStoreResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::UpdateEventDataStore, request, handler, context);
  }
 
  virtual Model::UpdateTrailOutcome UpdateTrail(const Model::UpdateTrailRequest& request) const;
 
  template <typename UpdateTrailRequestT = Model::UpdateTrailRequest>
  Model::UpdateTrailOutcomeCallable UpdateTrailCallable(const UpdateTrailRequestT& request) const {
    return SubmitCallable(&CloudTrailClient::UpdateTrail, request);
  }
 
  template <typename UpdateTrailRequestT = Model::UpdateTrailRequest>
  void UpdateTrailAsync(const UpdateTrailRequestT& request, const UpdateTrailResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudTrailClient::UpdateTrail, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<CloudTrailEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<CloudTrailClient>;
  void init(const CloudTrailClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, CloudTrailError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  CloudTrailClientConfiguration m_clientConfiguration;
  std::shared_ptr<CloudTrailEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace CloudTrail
}  // namespace Aws