CloudTrailClient.h

 
#pragma once
#include <aws/cloudtrail/CloudTrail_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/cloudtrail/CloudTrailServiceClientModel.h>
 
namespace Aws
{
namespace CloudTrail
{
  class AWS_CLOUDTRAIL_API CloudTrailClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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 PutEventConfigurationRequestT& request, const PutEventConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) 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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<CloudTrailEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<CloudTrailClient>;
      void init(const CloudTrailClientConfiguration& clientConfiguration);
 
      CloudTrailClientConfiguration m_clientConfiguration;
      std::shared_ptr<CloudTrailEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace CloudTrail
} // namespace Aws