CloudWatchLogsClient.h

 
#pragma once
#include <aws/logs/CloudWatchLogs_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/logs/CloudWatchLogsServiceClientModel.h>
 
namespace Aws
{
namespace CloudWatchLogs
{
  class AWS_CLOUDWATCHLOGS_API CloudWatchLogsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<CloudWatchLogsClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef CloudWatchLogsClientConfiguration ClientConfigurationType;
      typedef CloudWatchLogsEndpointProvider EndpointProviderType;
 
        CloudWatchLogsClient(const Aws::CloudWatchLogs::CloudWatchLogsClientConfiguration& clientConfiguration = Aws::CloudWatchLogs::CloudWatchLogsClientConfiguration(),
                             std::shared_ptr<CloudWatchLogsEndpointProviderBase> endpointProvider = nullptr);
 
        CloudWatchLogsClient(const Aws::Auth::AWSCredentials& credentials,
                             std::shared_ptr<CloudWatchLogsEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::CloudWatchLogs::CloudWatchLogsClientConfiguration& clientConfiguration = Aws::CloudWatchLogs::CloudWatchLogsClientConfiguration());
 
        CloudWatchLogsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             std::shared_ptr<CloudWatchLogsEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::CloudWatchLogs::CloudWatchLogsClientConfiguration& clientConfiguration = Aws::CloudWatchLogs::CloudWatchLogsClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        CloudWatchLogsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        CloudWatchLogsClient(const Aws::Auth::AWSCredentials& credentials,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
        CloudWatchLogsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~CloudWatchLogsClient();
 
        virtual Model::AssociateKmsKeyOutcome AssociateKmsKey(const Model::AssociateKmsKeyRequest& request) const;
 
        template<typename AssociateKmsKeyRequestT = Model::AssociateKmsKeyRequest>
        Model::AssociateKmsKeyOutcomeCallable AssociateKmsKeyCallable(const AssociateKmsKeyRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::AssociateKmsKey, request);
        }
 
        template<typename AssociateKmsKeyRequestT = Model::AssociateKmsKeyRequest>
        void AssociateKmsKeyAsync(const AssociateKmsKeyRequestT& request, const AssociateKmsKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::AssociateKmsKey, request, handler, context);
        }
 
        virtual Model::CancelExportTaskOutcome CancelExportTask(const Model::CancelExportTaskRequest& request) const;
 
        template<typename CancelExportTaskRequestT = Model::CancelExportTaskRequest>
        Model::CancelExportTaskOutcomeCallable CancelExportTaskCallable(const CancelExportTaskRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::CancelExportTask, request);
        }
 
        template<typename CancelExportTaskRequestT = Model::CancelExportTaskRequest>
        void CancelExportTaskAsync(const CancelExportTaskRequestT& request, const CancelExportTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::CancelExportTask, request, handler, context);
        }
 
        virtual Model::CreateDeliveryOutcome CreateDelivery(const Model::CreateDeliveryRequest& request) const;
 
        template<typename CreateDeliveryRequestT = Model::CreateDeliveryRequest>
        Model::CreateDeliveryOutcomeCallable CreateDeliveryCallable(const CreateDeliveryRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::CreateDelivery, request);
        }
 
        template<typename CreateDeliveryRequestT = Model::CreateDeliveryRequest>
        void CreateDeliveryAsync(const CreateDeliveryRequestT& request, const CreateDeliveryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::CreateDelivery, request, handler, context);
        }
 
        virtual Model::CreateExportTaskOutcome CreateExportTask(const Model::CreateExportTaskRequest& request) const;
 
        template<typename CreateExportTaskRequestT = Model::CreateExportTaskRequest>
        Model::CreateExportTaskOutcomeCallable CreateExportTaskCallable(const CreateExportTaskRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::CreateExportTask, request);
        }
 
        template<typename CreateExportTaskRequestT = Model::CreateExportTaskRequest>
        void CreateExportTaskAsync(const CreateExportTaskRequestT& request, const CreateExportTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::CreateExportTask, request, handler, context);
        }
 
        virtual Model::CreateLogAnomalyDetectorOutcome CreateLogAnomalyDetector(const Model::CreateLogAnomalyDetectorRequest& request) const;
 
        template<typename CreateLogAnomalyDetectorRequestT = Model::CreateLogAnomalyDetectorRequest>
        Model::CreateLogAnomalyDetectorOutcomeCallable CreateLogAnomalyDetectorCallable(const CreateLogAnomalyDetectorRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::CreateLogAnomalyDetector, request);
        }
 
        template<typename CreateLogAnomalyDetectorRequestT = Model::CreateLogAnomalyDetectorRequest>
        void CreateLogAnomalyDetectorAsync(const CreateLogAnomalyDetectorRequestT& request, const CreateLogAnomalyDetectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::CreateLogAnomalyDetector, request, handler, context);
        }
 
        virtual Model::CreateLogGroupOutcome CreateLogGroup(const Model::CreateLogGroupRequest& request) const;
 
        template<typename CreateLogGroupRequestT = Model::CreateLogGroupRequest>
        Model::CreateLogGroupOutcomeCallable CreateLogGroupCallable(const CreateLogGroupRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::CreateLogGroup, request);
        }
 
        template<typename CreateLogGroupRequestT = Model::CreateLogGroupRequest>
        void CreateLogGroupAsync(const CreateLogGroupRequestT& request, const CreateLogGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::CreateLogGroup, request, handler, context);
        }
 
        virtual Model::CreateLogStreamOutcome CreateLogStream(const Model::CreateLogStreamRequest& request) const;
 
        template<typename CreateLogStreamRequestT = Model::CreateLogStreamRequest>
        Model::CreateLogStreamOutcomeCallable CreateLogStreamCallable(const CreateLogStreamRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::CreateLogStream, request);
        }
 
        template<typename CreateLogStreamRequestT = Model::CreateLogStreamRequest>
        void CreateLogStreamAsync(const CreateLogStreamRequestT& request, const CreateLogStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::CreateLogStream, request, handler, context);
        }
 
        virtual Model::DeleteAccountPolicyOutcome DeleteAccountPolicy(const Model::DeleteAccountPolicyRequest& request) const;
 
        template<typename DeleteAccountPolicyRequestT = Model::DeleteAccountPolicyRequest>
        Model::DeleteAccountPolicyOutcomeCallable DeleteAccountPolicyCallable(const DeleteAccountPolicyRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DeleteAccountPolicy, request);
        }
 
        template<typename DeleteAccountPolicyRequestT = Model::DeleteAccountPolicyRequest>
        void DeleteAccountPolicyAsync(const DeleteAccountPolicyRequestT& request, const DeleteAccountPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DeleteAccountPolicy, request, handler, context);
        }
 
        virtual Model::DeleteDataProtectionPolicyOutcome DeleteDataProtectionPolicy(const Model::DeleteDataProtectionPolicyRequest& request) const;
 
        template<typename DeleteDataProtectionPolicyRequestT = Model::DeleteDataProtectionPolicyRequest>
        Model::DeleteDataProtectionPolicyOutcomeCallable DeleteDataProtectionPolicyCallable(const DeleteDataProtectionPolicyRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DeleteDataProtectionPolicy, request);
        }
 
        template<typename DeleteDataProtectionPolicyRequestT = Model::DeleteDataProtectionPolicyRequest>
        void DeleteDataProtectionPolicyAsync(const DeleteDataProtectionPolicyRequestT& request, const DeleteDataProtectionPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DeleteDataProtectionPolicy, request, handler, context);
        }
 
        virtual Model::DeleteDeliveryOutcome DeleteDelivery(const Model::DeleteDeliveryRequest& request) const;
 
        template<typename DeleteDeliveryRequestT = Model::DeleteDeliveryRequest>
        Model::DeleteDeliveryOutcomeCallable DeleteDeliveryCallable(const DeleteDeliveryRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DeleteDelivery, request);
        }
 
        template<typename DeleteDeliveryRequestT = Model::DeleteDeliveryRequest>
        void DeleteDeliveryAsync(const DeleteDeliveryRequestT& request, const DeleteDeliveryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DeleteDelivery, request, handler, context);
        }
 
        virtual Model::DeleteDeliveryDestinationOutcome DeleteDeliveryDestination(const Model::DeleteDeliveryDestinationRequest& request) const;
 
        template<typename DeleteDeliveryDestinationRequestT = Model::DeleteDeliveryDestinationRequest>
        Model::DeleteDeliveryDestinationOutcomeCallable DeleteDeliveryDestinationCallable(const DeleteDeliveryDestinationRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DeleteDeliveryDestination, request);
        }
 
        template<typename DeleteDeliveryDestinationRequestT = Model::DeleteDeliveryDestinationRequest>
        void DeleteDeliveryDestinationAsync(const DeleteDeliveryDestinationRequestT& request, const DeleteDeliveryDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DeleteDeliveryDestination, request, handler, context);
        }
 
        virtual Model::DeleteDeliveryDestinationPolicyOutcome DeleteDeliveryDestinationPolicy(const Model::DeleteDeliveryDestinationPolicyRequest& request) const;
 
        template<typename DeleteDeliveryDestinationPolicyRequestT = Model::DeleteDeliveryDestinationPolicyRequest>
        Model::DeleteDeliveryDestinationPolicyOutcomeCallable DeleteDeliveryDestinationPolicyCallable(const DeleteDeliveryDestinationPolicyRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DeleteDeliveryDestinationPolicy, request);
        }
 
        template<typename DeleteDeliveryDestinationPolicyRequestT = Model::DeleteDeliveryDestinationPolicyRequest>
        void DeleteDeliveryDestinationPolicyAsync(const DeleteDeliveryDestinationPolicyRequestT& request, const DeleteDeliveryDestinationPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DeleteDeliveryDestinationPolicy, request, handler, context);
        }
 
        virtual Model::DeleteDeliverySourceOutcome DeleteDeliverySource(const Model::DeleteDeliverySourceRequest& request) const;
 
        template<typename DeleteDeliverySourceRequestT = Model::DeleteDeliverySourceRequest>
        Model::DeleteDeliverySourceOutcomeCallable DeleteDeliverySourceCallable(const DeleteDeliverySourceRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DeleteDeliverySource, request);
        }
 
        template<typename DeleteDeliverySourceRequestT = Model::DeleteDeliverySourceRequest>
        void DeleteDeliverySourceAsync(const DeleteDeliverySourceRequestT& request, const DeleteDeliverySourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DeleteDeliverySource, request, handler, context);
        }
 
        virtual Model::DeleteDestinationOutcome DeleteDestination(const Model::DeleteDestinationRequest& request) const;
 
        template<typename DeleteDestinationRequestT = Model::DeleteDestinationRequest>
        Model::DeleteDestinationOutcomeCallable DeleteDestinationCallable(const DeleteDestinationRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DeleteDestination, request);
        }
 
        template<typename DeleteDestinationRequestT = Model::DeleteDestinationRequest>
        void DeleteDestinationAsync(const DeleteDestinationRequestT& request, const DeleteDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DeleteDestination, request, handler, context);
        }
 
        virtual Model::DeleteIndexPolicyOutcome DeleteIndexPolicy(const Model::DeleteIndexPolicyRequest& request) const;
 
        template<typename DeleteIndexPolicyRequestT = Model::DeleteIndexPolicyRequest>
        Model::DeleteIndexPolicyOutcomeCallable DeleteIndexPolicyCallable(const DeleteIndexPolicyRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DeleteIndexPolicy, request);
        }
 
        template<typename DeleteIndexPolicyRequestT = Model::DeleteIndexPolicyRequest>
        void DeleteIndexPolicyAsync(const DeleteIndexPolicyRequestT& request, const DeleteIndexPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DeleteIndexPolicy, request, handler, context);
        }
 
        virtual Model::DeleteIntegrationOutcome DeleteIntegration(const Model::DeleteIntegrationRequest& request) const;
 
        template<typename DeleteIntegrationRequestT = Model::DeleteIntegrationRequest>
        Model::DeleteIntegrationOutcomeCallable DeleteIntegrationCallable(const DeleteIntegrationRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DeleteIntegration, request);
        }
 
        template<typename DeleteIntegrationRequestT = Model::DeleteIntegrationRequest>
        void DeleteIntegrationAsync(const DeleteIntegrationRequestT& request, const DeleteIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DeleteIntegration, request, handler, context);
        }
 
        virtual Model::DeleteLogAnomalyDetectorOutcome DeleteLogAnomalyDetector(const Model::DeleteLogAnomalyDetectorRequest& request) const;
 
        template<typename DeleteLogAnomalyDetectorRequestT = Model::DeleteLogAnomalyDetectorRequest>
        Model::DeleteLogAnomalyDetectorOutcomeCallable DeleteLogAnomalyDetectorCallable(const DeleteLogAnomalyDetectorRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DeleteLogAnomalyDetector, request);
        }
 
        template<typename DeleteLogAnomalyDetectorRequestT = Model::DeleteLogAnomalyDetectorRequest>
        void DeleteLogAnomalyDetectorAsync(const DeleteLogAnomalyDetectorRequestT& request, const DeleteLogAnomalyDetectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DeleteLogAnomalyDetector, request, handler, context);
        }
 
        virtual Model::DeleteLogGroupOutcome DeleteLogGroup(const Model::DeleteLogGroupRequest& request) const;
 
        template<typename DeleteLogGroupRequestT = Model::DeleteLogGroupRequest>
        Model::DeleteLogGroupOutcomeCallable DeleteLogGroupCallable(const DeleteLogGroupRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DeleteLogGroup, request);
        }
 
        template<typename DeleteLogGroupRequestT = Model::DeleteLogGroupRequest>
        void DeleteLogGroupAsync(const DeleteLogGroupRequestT& request, const DeleteLogGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DeleteLogGroup, request, handler, context);
        }
 
        virtual Model::DeleteLogStreamOutcome DeleteLogStream(const Model::DeleteLogStreamRequest& request) const;
 
        template<typename DeleteLogStreamRequestT = Model::DeleteLogStreamRequest>
        Model::DeleteLogStreamOutcomeCallable DeleteLogStreamCallable(const DeleteLogStreamRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DeleteLogStream, request);
        }
 
        template<typename DeleteLogStreamRequestT = Model::DeleteLogStreamRequest>
        void DeleteLogStreamAsync(const DeleteLogStreamRequestT& request, const DeleteLogStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DeleteLogStream, request, handler, context);
        }
 
        virtual Model::DeleteMetricFilterOutcome DeleteMetricFilter(const Model::DeleteMetricFilterRequest& request) const;
 
        template<typename DeleteMetricFilterRequestT = Model::DeleteMetricFilterRequest>
        Model::DeleteMetricFilterOutcomeCallable DeleteMetricFilterCallable(const DeleteMetricFilterRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DeleteMetricFilter, request);
        }
 
        template<typename DeleteMetricFilterRequestT = Model::DeleteMetricFilterRequest>
        void DeleteMetricFilterAsync(const DeleteMetricFilterRequestT& request, const DeleteMetricFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DeleteMetricFilter, request, handler, context);
        }
 
        virtual Model::DeleteQueryDefinitionOutcome DeleteQueryDefinition(const Model::DeleteQueryDefinitionRequest& request) const;
 
        template<typename DeleteQueryDefinitionRequestT = Model::DeleteQueryDefinitionRequest>
        Model::DeleteQueryDefinitionOutcomeCallable DeleteQueryDefinitionCallable(const DeleteQueryDefinitionRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DeleteQueryDefinition, request);
        }
 
        template<typename DeleteQueryDefinitionRequestT = Model::DeleteQueryDefinitionRequest>
        void DeleteQueryDefinitionAsync(const DeleteQueryDefinitionRequestT& request, const DeleteQueryDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DeleteQueryDefinition, 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(&CloudWatchLogsClient::DeleteResourcePolicy, request);
        }
 
        template<typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
        void DeleteResourcePolicyAsync(const DeleteResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteResourcePolicyRequestT& request = {}) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DeleteResourcePolicy, request, handler, context);
        }
 
        virtual Model::DeleteRetentionPolicyOutcome DeleteRetentionPolicy(const Model::DeleteRetentionPolicyRequest& request) const;
 
        template<typename DeleteRetentionPolicyRequestT = Model::DeleteRetentionPolicyRequest>
        Model::DeleteRetentionPolicyOutcomeCallable DeleteRetentionPolicyCallable(const DeleteRetentionPolicyRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DeleteRetentionPolicy, request);
        }
 
        template<typename DeleteRetentionPolicyRequestT = Model::DeleteRetentionPolicyRequest>
        void DeleteRetentionPolicyAsync(const DeleteRetentionPolicyRequestT& request, const DeleteRetentionPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DeleteRetentionPolicy, request, handler, context);
        }
 
        virtual Model::DeleteSubscriptionFilterOutcome DeleteSubscriptionFilter(const Model::DeleteSubscriptionFilterRequest& request) const;
 
        template<typename DeleteSubscriptionFilterRequestT = Model::DeleteSubscriptionFilterRequest>
        Model::DeleteSubscriptionFilterOutcomeCallable DeleteSubscriptionFilterCallable(const DeleteSubscriptionFilterRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DeleteSubscriptionFilter, request);
        }
 
        template<typename DeleteSubscriptionFilterRequestT = Model::DeleteSubscriptionFilterRequest>
        void DeleteSubscriptionFilterAsync(const DeleteSubscriptionFilterRequestT& request, const DeleteSubscriptionFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DeleteSubscriptionFilter, request, handler, context);
        }
 
        virtual Model::DeleteTransformerOutcome DeleteTransformer(const Model::DeleteTransformerRequest& request) const;
 
        template<typename DeleteTransformerRequestT = Model::DeleteTransformerRequest>
        Model::DeleteTransformerOutcomeCallable DeleteTransformerCallable(const DeleteTransformerRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DeleteTransformer, request);
        }
 
        template<typename DeleteTransformerRequestT = Model::DeleteTransformerRequest>
        void DeleteTransformerAsync(const DeleteTransformerRequestT& request, const DeleteTransformerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DeleteTransformer, request, handler, context);
        }
 
        virtual Model::DescribeAccountPoliciesOutcome DescribeAccountPolicies(const Model::DescribeAccountPoliciesRequest& request) const;
 
        template<typename DescribeAccountPoliciesRequestT = Model::DescribeAccountPoliciesRequest>
        Model::DescribeAccountPoliciesOutcomeCallable DescribeAccountPoliciesCallable(const DescribeAccountPoliciesRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DescribeAccountPolicies, request);
        }
 
        template<typename DescribeAccountPoliciesRequestT = Model::DescribeAccountPoliciesRequest>
        void DescribeAccountPoliciesAsync(const DescribeAccountPoliciesRequestT& request, const DescribeAccountPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DescribeAccountPolicies, request, handler, context);
        }
 
        virtual Model::DescribeConfigurationTemplatesOutcome DescribeConfigurationTemplates(const Model::DescribeConfigurationTemplatesRequest& request = {}) const;
 
        template<typename DescribeConfigurationTemplatesRequestT = Model::DescribeConfigurationTemplatesRequest>
        Model::DescribeConfigurationTemplatesOutcomeCallable DescribeConfigurationTemplatesCallable(const DescribeConfigurationTemplatesRequestT& request = {}) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DescribeConfigurationTemplates, request);
        }
 
        template<typename DescribeConfigurationTemplatesRequestT = Model::DescribeConfigurationTemplatesRequest>
        void DescribeConfigurationTemplatesAsync(const DescribeConfigurationTemplatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeConfigurationTemplatesRequestT& request = {}) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DescribeConfigurationTemplates, request, handler, context);
        }
 
        virtual Model::DescribeDeliveriesOutcome DescribeDeliveries(const Model::DescribeDeliveriesRequest& request = {}) const;
 
        template<typename DescribeDeliveriesRequestT = Model::DescribeDeliveriesRequest>
        Model::DescribeDeliveriesOutcomeCallable DescribeDeliveriesCallable(const DescribeDeliveriesRequestT& request = {}) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DescribeDeliveries, request);
        }
 
        template<typename DescribeDeliveriesRequestT = Model::DescribeDeliveriesRequest>
        void DescribeDeliveriesAsync(const DescribeDeliveriesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeDeliveriesRequestT& request = {}) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DescribeDeliveries, request, handler, context);
        }
 
        virtual Model::DescribeDeliveryDestinationsOutcome DescribeDeliveryDestinations(const Model::DescribeDeliveryDestinationsRequest& request = {}) const;
 
        template<typename DescribeDeliveryDestinationsRequestT = Model::DescribeDeliveryDestinationsRequest>
        Model::DescribeDeliveryDestinationsOutcomeCallable DescribeDeliveryDestinationsCallable(const DescribeDeliveryDestinationsRequestT& request = {}) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DescribeDeliveryDestinations, request);
        }
 
        template<typename DescribeDeliveryDestinationsRequestT = Model::DescribeDeliveryDestinationsRequest>
        void DescribeDeliveryDestinationsAsync(const DescribeDeliveryDestinationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeDeliveryDestinationsRequestT& request = {}) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DescribeDeliveryDestinations, request, handler, context);
        }
 
        virtual Model::DescribeDeliverySourcesOutcome DescribeDeliverySources(const Model::DescribeDeliverySourcesRequest& request = {}) const;
 
        template<typename DescribeDeliverySourcesRequestT = Model::DescribeDeliverySourcesRequest>
        Model::DescribeDeliverySourcesOutcomeCallable DescribeDeliverySourcesCallable(const DescribeDeliverySourcesRequestT& request = {}) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DescribeDeliverySources, request);
        }
 
        template<typename DescribeDeliverySourcesRequestT = Model::DescribeDeliverySourcesRequest>
        void DescribeDeliverySourcesAsync(const DescribeDeliverySourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeDeliverySourcesRequestT& request = {}) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DescribeDeliverySources, request, handler, context);
        }
 
        virtual Model::DescribeDestinationsOutcome DescribeDestinations(const Model::DescribeDestinationsRequest& request = {}) const;
 
        template<typename DescribeDestinationsRequestT = Model::DescribeDestinationsRequest>
        Model::DescribeDestinationsOutcomeCallable DescribeDestinationsCallable(const DescribeDestinationsRequestT& request = {}) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DescribeDestinations, request);
        }
 
        template<typename DescribeDestinationsRequestT = Model::DescribeDestinationsRequest>
        void DescribeDestinationsAsync(const DescribeDestinationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeDestinationsRequestT& request = {}) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DescribeDestinations, request, handler, context);
        }
 
        virtual Model::DescribeExportTasksOutcome DescribeExportTasks(const Model::DescribeExportTasksRequest& request = {}) const;
 
        template<typename DescribeExportTasksRequestT = Model::DescribeExportTasksRequest>
        Model::DescribeExportTasksOutcomeCallable DescribeExportTasksCallable(const DescribeExportTasksRequestT& request = {}) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DescribeExportTasks, request);
        }
 
        template<typename DescribeExportTasksRequestT = Model::DescribeExportTasksRequest>
        void DescribeExportTasksAsync(const DescribeExportTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeExportTasksRequestT& request = {}) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DescribeExportTasks, request, handler, context);
        }
 
        virtual Model::DescribeFieldIndexesOutcome DescribeFieldIndexes(const Model::DescribeFieldIndexesRequest& request) const;
 
        template<typename DescribeFieldIndexesRequestT = Model::DescribeFieldIndexesRequest>
        Model::DescribeFieldIndexesOutcomeCallable DescribeFieldIndexesCallable(const DescribeFieldIndexesRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DescribeFieldIndexes, request);
        }
 
        template<typename DescribeFieldIndexesRequestT = Model::DescribeFieldIndexesRequest>
        void DescribeFieldIndexesAsync(const DescribeFieldIndexesRequestT& request, const DescribeFieldIndexesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DescribeFieldIndexes, request, handler, context);
        }
 
        virtual Model::DescribeIndexPoliciesOutcome DescribeIndexPolicies(const Model::DescribeIndexPoliciesRequest& request) const;
 
        template<typename DescribeIndexPoliciesRequestT = Model::DescribeIndexPoliciesRequest>
        Model::DescribeIndexPoliciesOutcomeCallable DescribeIndexPoliciesCallable(const DescribeIndexPoliciesRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DescribeIndexPolicies, request);
        }
 
        template<typename DescribeIndexPoliciesRequestT = Model::DescribeIndexPoliciesRequest>
        void DescribeIndexPoliciesAsync(const DescribeIndexPoliciesRequestT& request, const DescribeIndexPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DescribeIndexPolicies, request, handler, context);
        }
 
        virtual Model::DescribeLogGroupsOutcome DescribeLogGroups(const Model::DescribeLogGroupsRequest& request = {}) const;
 
        template<typename DescribeLogGroupsRequestT = Model::DescribeLogGroupsRequest>
        Model::DescribeLogGroupsOutcomeCallable DescribeLogGroupsCallable(const DescribeLogGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DescribeLogGroups, request);
        }
 
        template<typename DescribeLogGroupsRequestT = Model::DescribeLogGroupsRequest>
        void DescribeLogGroupsAsync(const DescribeLogGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeLogGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DescribeLogGroups, request, handler, context);
        }
 
        virtual Model::DescribeLogStreamsOutcome DescribeLogStreams(const Model::DescribeLogStreamsRequest& request = {}) const;
 
        template<typename DescribeLogStreamsRequestT = Model::DescribeLogStreamsRequest>
        Model::DescribeLogStreamsOutcomeCallable DescribeLogStreamsCallable(const DescribeLogStreamsRequestT& request = {}) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DescribeLogStreams, request);
        }
 
        template<typename DescribeLogStreamsRequestT = Model::DescribeLogStreamsRequest>
        void DescribeLogStreamsAsync(const DescribeLogStreamsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeLogStreamsRequestT& request = {}) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DescribeLogStreams, request, handler, context);
        }
 
        virtual Model::DescribeMetricFiltersOutcome DescribeMetricFilters(const Model::DescribeMetricFiltersRequest& request = {}) const;
 
        template<typename DescribeMetricFiltersRequestT = Model::DescribeMetricFiltersRequest>
        Model::DescribeMetricFiltersOutcomeCallable DescribeMetricFiltersCallable(const DescribeMetricFiltersRequestT& request = {}) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DescribeMetricFilters, request);
        }
 
        template<typename DescribeMetricFiltersRequestT = Model::DescribeMetricFiltersRequest>
        void DescribeMetricFiltersAsync(const DescribeMetricFiltersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeMetricFiltersRequestT& request = {}) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DescribeMetricFilters, request, handler, context);
        }
 
        virtual Model::DescribeQueriesOutcome DescribeQueries(const Model::DescribeQueriesRequest& request = {}) const;
 
        template<typename DescribeQueriesRequestT = Model::DescribeQueriesRequest>
        Model::DescribeQueriesOutcomeCallable DescribeQueriesCallable(const DescribeQueriesRequestT& request = {}) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DescribeQueries, request);
        }
 
        template<typename DescribeQueriesRequestT = Model::DescribeQueriesRequest>
        void DescribeQueriesAsync(const DescribeQueriesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeQueriesRequestT& request = {}) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DescribeQueries, request, handler, context);
        }
 
        virtual Model::DescribeQueryDefinitionsOutcome DescribeQueryDefinitions(const Model::DescribeQueryDefinitionsRequest& request = {}) const;
 
        template<typename DescribeQueryDefinitionsRequestT = Model::DescribeQueryDefinitionsRequest>
        Model::DescribeQueryDefinitionsOutcomeCallable DescribeQueryDefinitionsCallable(const DescribeQueryDefinitionsRequestT& request = {}) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DescribeQueryDefinitions, request);
        }
 
        template<typename DescribeQueryDefinitionsRequestT = Model::DescribeQueryDefinitionsRequest>
        void DescribeQueryDefinitionsAsync(const DescribeQueryDefinitionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeQueryDefinitionsRequestT& request = {}) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DescribeQueryDefinitions, request, handler, context);
        }
 
        virtual Model::DescribeResourcePoliciesOutcome DescribeResourcePolicies(const Model::DescribeResourcePoliciesRequest& request = {}) const;
 
        template<typename DescribeResourcePoliciesRequestT = Model::DescribeResourcePoliciesRequest>
        Model::DescribeResourcePoliciesOutcomeCallable DescribeResourcePoliciesCallable(const DescribeResourcePoliciesRequestT& request = {}) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DescribeResourcePolicies, request);
        }
 
        template<typename DescribeResourcePoliciesRequestT = Model::DescribeResourcePoliciesRequest>
        void DescribeResourcePoliciesAsync(const DescribeResourcePoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeResourcePoliciesRequestT& request = {}) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DescribeResourcePolicies, request, handler, context);
        }
 
        virtual Model::DescribeSubscriptionFiltersOutcome DescribeSubscriptionFilters(const Model::DescribeSubscriptionFiltersRequest& request) const;
 
        template<typename DescribeSubscriptionFiltersRequestT = Model::DescribeSubscriptionFiltersRequest>
        Model::DescribeSubscriptionFiltersOutcomeCallable DescribeSubscriptionFiltersCallable(const DescribeSubscriptionFiltersRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DescribeSubscriptionFilters, request);
        }
 
        template<typename DescribeSubscriptionFiltersRequestT = Model::DescribeSubscriptionFiltersRequest>
        void DescribeSubscriptionFiltersAsync(const DescribeSubscriptionFiltersRequestT& request, const DescribeSubscriptionFiltersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DescribeSubscriptionFilters, request, handler, context);
        }
 
        virtual Model::DisassociateKmsKeyOutcome DisassociateKmsKey(const Model::DisassociateKmsKeyRequest& request = {}) const;
 
        template<typename DisassociateKmsKeyRequestT = Model::DisassociateKmsKeyRequest>
        Model::DisassociateKmsKeyOutcomeCallable DisassociateKmsKeyCallable(const DisassociateKmsKeyRequestT& request = {}) const
        {
            return SubmitCallable(&CloudWatchLogsClient::DisassociateKmsKey, request);
        }
 
        template<typename DisassociateKmsKeyRequestT = Model::DisassociateKmsKeyRequest>
        void DisassociateKmsKeyAsync(const DisassociateKmsKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DisassociateKmsKeyRequestT& request = {}) const
        {
            return SubmitAsync(&CloudWatchLogsClient::DisassociateKmsKey, request, handler, context);
        }
 
        virtual Model::FilterLogEventsOutcome FilterLogEvents(const Model::FilterLogEventsRequest& request = {}) const;
 
        template<typename FilterLogEventsRequestT = Model::FilterLogEventsRequest>
        Model::FilterLogEventsOutcomeCallable FilterLogEventsCallable(const FilterLogEventsRequestT& request = {}) const
        {
            return SubmitCallable(&CloudWatchLogsClient::FilterLogEvents, request);
        }
 
        template<typename FilterLogEventsRequestT = Model::FilterLogEventsRequest>
        void FilterLogEventsAsync(const FilterLogEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const FilterLogEventsRequestT& request = {}) const
        {
            return SubmitAsync(&CloudWatchLogsClient::FilterLogEvents, request, handler, context);
        }
 
        virtual Model::GetDataProtectionPolicyOutcome GetDataProtectionPolicy(const Model::GetDataProtectionPolicyRequest& request) const;
 
        template<typename GetDataProtectionPolicyRequestT = Model::GetDataProtectionPolicyRequest>
        Model::GetDataProtectionPolicyOutcomeCallable GetDataProtectionPolicyCallable(const GetDataProtectionPolicyRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::GetDataProtectionPolicy, request);
        }
 
        template<typename GetDataProtectionPolicyRequestT = Model::GetDataProtectionPolicyRequest>
        void GetDataProtectionPolicyAsync(const GetDataProtectionPolicyRequestT& request, const GetDataProtectionPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::GetDataProtectionPolicy, request, handler, context);
        }
 
        virtual Model::GetDeliveryOutcome GetDelivery(const Model::GetDeliveryRequest& request) const;
 
        template<typename GetDeliveryRequestT = Model::GetDeliveryRequest>
        Model::GetDeliveryOutcomeCallable GetDeliveryCallable(const GetDeliveryRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::GetDelivery, request);
        }
 
        template<typename GetDeliveryRequestT = Model::GetDeliveryRequest>
        void GetDeliveryAsync(const GetDeliveryRequestT& request, const GetDeliveryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::GetDelivery, request, handler, context);
        }
 
        virtual Model::GetDeliveryDestinationOutcome GetDeliveryDestination(const Model::GetDeliveryDestinationRequest& request) const;
 
        template<typename GetDeliveryDestinationRequestT = Model::GetDeliveryDestinationRequest>
        Model::GetDeliveryDestinationOutcomeCallable GetDeliveryDestinationCallable(const GetDeliveryDestinationRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::GetDeliveryDestination, request);
        }
 
        template<typename GetDeliveryDestinationRequestT = Model::GetDeliveryDestinationRequest>
        void GetDeliveryDestinationAsync(const GetDeliveryDestinationRequestT& request, const GetDeliveryDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::GetDeliveryDestination, request, handler, context);
        }
 
        virtual Model::GetDeliveryDestinationPolicyOutcome GetDeliveryDestinationPolicy(const Model::GetDeliveryDestinationPolicyRequest& request) const;
 
        template<typename GetDeliveryDestinationPolicyRequestT = Model::GetDeliveryDestinationPolicyRequest>
        Model::GetDeliveryDestinationPolicyOutcomeCallable GetDeliveryDestinationPolicyCallable(const GetDeliveryDestinationPolicyRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::GetDeliveryDestinationPolicy, request);
        }
 
        template<typename GetDeliveryDestinationPolicyRequestT = Model::GetDeliveryDestinationPolicyRequest>
        void GetDeliveryDestinationPolicyAsync(const GetDeliveryDestinationPolicyRequestT& request, const GetDeliveryDestinationPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::GetDeliveryDestinationPolicy, request, handler, context);
        }
 
        virtual Model::GetDeliverySourceOutcome GetDeliverySource(const Model::GetDeliverySourceRequest& request) const;
 
        template<typename GetDeliverySourceRequestT = Model::GetDeliverySourceRequest>
        Model::GetDeliverySourceOutcomeCallable GetDeliverySourceCallable(const GetDeliverySourceRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::GetDeliverySource, request);
        }
 
        template<typename GetDeliverySourceRequestT = Model::GetDeliverySourceRequest>
        void GetDeliverySourceAsync(const GetDeliverySourceRequestT& request, const GetDeliverySourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::GetDeliverySource, request, handler, context);
        }
 
        virtual Model::GetIntegrationOutcome GetIntegration(const Model::GetIntegrationRequest& request) const;
 
        template<typename GetIntegrationRequestT = Model::GetIntegrationRequest>
        Model::GetIntegrationOutcomeCallable GetIntegrationCallable(const GetIntegrationRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::GetIntegration, request);
        }
 
        template<typename GetIntegrationRequestT = Model::GetIntegrationRequest>
        void GetIntegrationAsync(const GetIntegrationRequestT& request, const GetIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::GetIntegration, request, handler, context);
        }
 
        virtual Model::GetLogAnomalyDetectorOutcome GetLogAnomalyDetector(const Model::GetLogAnomalyDetectorRequest& request) const;
 
        template<typename GetLogAnomalyDetectorRequestT = Model::GetLogAnomalyDetectorRequest>
        Model::GetLogAnomalyDetectorOutcomeCallable GetLogAnomalyDetectorCallable(const GetLogAnomalyDetectorRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::GetLogAnomalyDetector, request);
        }
 
        template<typename GetLogAnomalyDetectorRequestT = Model::GetLogAnomalyDetectorRequest>
        void GetLogAnomalyDetectorAsync(const GetLogAnomalyDetectorRequestT& request, const GetLogAnomalyDetectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::GetLogAnomalyDetector, request, handler, context);
        }
 
        virtual Model::GetLogEventsOutcome GetLogEvents(const Model::GetLogEventsRequest& request) const;
 
        template<typename GetLogEventsRequestT = Model::GetLogEventsRequest>
        Model::GetLogEventsOutcomeCallable GetLogEventsCallable(const GetLogEventsRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::GetLogEvents, request);
        }
 
        template<typename GetLogEventsRequestT = Model::GetLogEventsRequest>
        void GetLogEventsAsync(const GetLogEventsRequestT& request, const GetLogEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::GetLogEvents, request, handler, context);
        }
 
        virtual Model::GetLogGroupFieldsOutcome GetLogGroupFields(const Model::GetLogGroupFieldsRequest& request = {}) const;
 
        template<typename GetLogGroupFieldsRequestT = Model::GetLogGroupFieldsRequest>
        Model::GetLogGroupFieldsOutcomeCallable GetLogGroupFieldsCallable(const GetLogGroupFieldsRequestT& request = {}) const
        {
            return SubmitCallable(&CloudWatchLogsClient::GetLogGroupFields, request);
        }
 
        template<typename GetLogGroupFieldsRequestT = Model::GetLogGroupFieldsRequest>
        void GetLogGroupFieldsAsync(const GetLogGroupFieldsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetLogGroupFieldsRequestT& request = {}) const
        {
            return SubmitAsync(&CloudWatchLogsClient::GetLogGroupFields, request, handler, context);
        }
 
        virtual Model::GetLogRecordOutcome GetLogRecord(const Model::GetLogRecordRequest& request) const;
 
        template<typename GetLogRecordRequestT = Model::GetLogRecordRequest>
        Model::GetLogRecordOutcomeCallable GetLogRecordCallable(const GetLogRecordRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::GetLogRecord, request);
        }
 
        template<typename GetLogRecordRequestT = Model::GetLogRecordRequest>
        void GetLogRecordAsync(const GetLogRecordRequestT& request, const GetLogRecordResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::GetLogRecord, 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(&CloudWatchLogsClient::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(&CloudWatchLogsClient::GetQueryResults, request, handler, context);
        }
 
        virtual Model::GetTransformerOutcome GetTransformer(const Model::GetTransformerRequest& request) const;
 
        template<typename GetTransformerRequestT = Model::GetTransformerRequest>
        Model::GetTransformerOutcomeCallable GetTransformerCallable(const GetTransformerRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::GetTransformer, request);
        }
 
        template<typename GetTransformerRequestT = Model::GetTransformerRequest>
        void GetTransformerAsync(const GetTransformerRequestT& request, const GetTransformerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::GetTransformer, request, handler, context);
        }
 
        virtual Model::ListAnomaliesOutcome ListAnomalies(const Model::ListAnomaliesRequest& request = {}) const;
 
        template<typename ListAnomaliesRequestT = Model::ListAnomaliesRequest>
        Model::ListAnomaliesOutcomeCallable ListAnomaliesCallable(const ListAnomaliesRequestT& request = {}) const
        {
            return SubmitCallable(&CloudWatchLogsClient::ListAnomalies, request);
        }
 
        template<typename ListAnomaliesRequestT = Model::ListAnomaliesRequest>
        void ListAnomaliesAsync(const ListAnomaliesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAnomaliesRequestT& request = {}) const
        {
            return SubmitAsync(&CloudWatchLogsClient::ListAnomalies, request, handler, context);
        }
 
        virtual Model::ListIntegrationsOutcome ListIntegrations(const Model::ListIntegrationsRequest& request = {}) const;
 
        template<typename ListIntegrationsRequestT = Model::ListIntegrationsRequest>
        Model::ListIntegrationsOutcomeCallable ListIntegrationsCallable(const ListIntegrationsRequestT& request = {}) const
        {
            return SubmitCallable(&CloudWatchLogsClient::ListIntegrations, request);
        }
 
        template<typename ListIntegrationsRequestT = Model::ListIntegrationsRequest>
        void ListIntegrationsAsync(const ListIntegrationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListIntegrationsRequestT& request = {}) const
        {
            return SubmitAsync(&CloudWatchLogsClient::ListIntegrations, request, handler, context);
        }
 
        virtual Model::ListLogAnomalyDetectorsOutcome ListLogAnomalyDetectors(const Model::ListLogAnomalyDetectorsRequest& request = {}) const;
 
        template<typename ListLogAnomalyDetectorsRequestT = Model::ListLogAnomalyDetectorsRequest>
        Model::ListLogAnomalyDetectorsOutcomeCallable ListLogAnomalyDetectorsCallable(const ListLogAnomalyDetectorsRequestT& request = {}) const
        {
            return SubmitCallable(&CloudWatchLogsClient::ListLogAnomalyDetectors, request);
        }
 
        template<typename ListLogAnomalyDetectorsRequestT = Model::ListLogAnomalyDetectorsRequest>
        void ListLogAnomalyDetectorsAsync(const ListLogAnomalyDetectorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListLogAnomalyDetectorsRequestT& request = {}) const
        {
            return SubmitAsync(&CloudWatchLogsClient::ListLogAnomalyDetectors, request, handler, context);
        }
 
        virtual Model::ListLogGroupsOutcome ListLogGroups(const Model::ListLogGroupsRequest& request = {}) const;
 
        template<typename ListLogGroupsRequestT = Model::ListLogGroupsRequest>
        Model::ListLogGroupsOutcomeCallable ListLogGroupsCallable(const ListLogGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&CloudWatchLogsClient::ListLogGroups, request);
        }
 
        template<typename ListLogGroupsRequestT = Model::ListLogGroupsRequest>
        void ListLogGroupsAsync(const ListLogGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListLogGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&CloudWatchLogsClient::ListLogGroups, request, handler, context);
        }
 
        virtual Model::ListLogGroupsForQueryOutcome ListLogGroupsForQuery(const Model::ListLogGroupsForQueryRequest& request) const;
 
        template<typename ListLogGroupsForQueryRequestT = Model::ListLogGroupsForQueryRequest>
        Model::ListLogGroupsForQueryOutcomeCallable ListLogGroupsForQueryCallable(const ListLogGroupsForQueryRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::ListLogGroupsForQuery, request);
        }
 
        template<typename ListLogGroupsForQueryRequestT = Model::ListLogGroupsForQueryRequest>
        void ListLogGroupsForQueryAsync(const ListLogGroupsForQueryRequestT& request, const ListLogGroupsForQueryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::ListLogGroupsForQuery, request, handler, context);
        }
 
        virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::ListTagsForResource, request);
        }
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PutAccountPolicyOutcome PutAccountPolicy(const Model::PutAccountPolicyRequest& request) const;
 
        template<typename PutAccountPolicyRequestT = Model::PutAccountPolicyRequest>
        Model::PutAccountPolicyOutcomeCallable PutAccountPolicyCallable(const PutAccountPolicyRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::PutAccountPolicy, request);
        }
 
        template<typename PutAccountPolicyRequestT = Model::PutAccountPolicyRequest>
        void PutAccountPolicyAsync(const PutAccountPolicyRequestT& request, const PutAccountPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::PutAccountPolicy, request, handler, context);
        }
 
        virtual Model::PutDataProtectionPolicyOutcome PutDataProtectionPolicy(const Model::PutDataProtectionPolicyRequest& request) const;
 
        template<typename PutDataProtectionPolicyRequestT = Model::PutDataProtectionPolicyRequest>
        Model::PutDataProtectionPolicyOutcomeCallable PutDataProtectionPolicyCallable(const PutDataProtectionPolicyRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::PutDataProtectionPolicy, request);
        }
 
        template<typename PutDataProtectionPolicyRequestT = Model::PutDataProtectionPolicyRequest>
        void PutDataProtectionPolicyAsync(const PutDataProtectionPolicyRequestT& request, const PutDataProtectionPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::PutDataProtectionPolicy, request, handler, context);
        }
 
        virtual Model::PutDeliveryDestinationOutcome PutDeliveryDestination(const Model::PutDeliveryDestinationRequest& request) const;
 
        template<typename PutDeliveryDestinationRequestT = Model::PutDeliveryDestinationRequest>
        Model::PutDeliveryDestinationOutcomeCallable PutDeliveryDestinationCallable(const PutDeliveryDestinationRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::PutDeliveryDestination, request);
        }
 
        template<typename PutDeliveryDestinationRequestT = Model::PutDeliveryDestinationRequest>
        void PutDeliveryDestinationAsync(const PutDeliveryDestinationRequestT& request, const PutDeliveryDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::PutDeliveryDestination, request, handler, context);
        }
 
        virtual Model::PutDeliveryDestinationPolicyOutcome PutDeliveryDestinationPolicy(const Model::PutDeliveryDestinationPolicyRequest& request) const;
 
        template<typename PutDeliveryDestinationPolicyRequestT = Model::PutDeliveryDestinationPolicyRequest>
        Model::PutDeliveryDestinationPolicyOutcomeCallable PutDeliveryDestinationPolicyCallable(const PutDeliveryDestinationPolicyRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::PutDeliveryDestinationPolicy, request);
        }
 
        template<typename PutDeliveryDestinationPolicyRequestT = Model::PutDeliveryDestinationPolicyRequest>
        void PutDeliveryDestinationPolicyAsync(const PutDeliveryDestinationPolicyRequestT& request, const PutDeliveryDestinationPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::PutDeliveryDestinationPolicy, request, handler, context);
        }
 
        virtual Model::PutDeliverySourceOutcome PutDeliverySource(const Model::PutDeliverySourceRequest& request) const;
 
        template<typename PutDeliverySourceRequestT = Model::PutDeliverySourceRequest>
        Model::PutDeliverySourceOutcomeCallable PutDeliverySourceCallable(const PutDeliverySourceRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::PutDeliverySource, request);
        }
 
        template<typename PutDeliverySourceRequestT = Model::PutDeliverySourceRequest>
        void PutDeliverySourceAsync(const PutDeliverySourceRequestT& request, const PutDeliverySourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::PutDeliverySource, request, handler, context);
        }
 
        virtual Model::PutDestinationOutcome PutDestination(const Model::PutDestinationRequest& request) const;
 
        template<typename PutDestinationRequestT = Model::PutDestinationRequest>
        Model::PutDestinationOutcomeCallable PutDestinationCallable(const PutDestinationRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::PutDestination, request);
        }
 
        template<typename PutDestinationRequestT = Model::PutDestinationRequest>
        void PutDestinationAsync(const PutDestinationRequestT& request, const PutDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::PutDestination, request, handler, context);
        }
 
        virtual Model::PutDestinationPolicyOutcome PutDestinationPolicy(const Model::PutDestinationPolicyRequest& request) const;
 
        template<typename PutDestinationPolicyRequestT = Model::PutDestinationPolicyRequest>
        Model::PutDestinationPolicyOutcomeCallable PutDestinationPolicyCallable(const PutDestinationPolicyRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::PutDestinationPolicy, request);
        }
 
        template<typename PutDestinationPolicyRequestT = Model::PutDestinationPolicyRequest>
        void PutDestinationPolicyAsync(const PutDestinationPolicyRequestT& request, const PutDestinationPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::PutDestinationPolicy, request, handler, context);
        }
 
        virtual Model::PutIndexPolicyOutcome PutIndexPolicy(const Model::PutIndexPolicyRequest& request) const;
 
        template<typename PutIndexPolicyRequestT = Model::PutIndexPolicyRequest>
        Model::PutIndexPolicyOutcomeCallable PutIndexPolicyCallable(const PutIndexPolicyRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::PutIndexPolicy, request);
        }
 
        template<typename PutIndexPolicyRequestT = Model::PutIndexPolicyRequest>
        void PutIndexPolicyAsync(const PutIndexPolicyRequestT& request, const PutIndexPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::PutIndexPolicy, request, handler, context);
        }
 
        virtual Model::PutIntegrationOutcome PutIntegration(const Model::PutIntegrationRequest& request) const;
 
        template<typename PutIntegrationRequestT = Model::PutIntegrationRequest>
        Model::PutIntegrationOutcomeCallable PutIntegrationCallable(const PutIntegrationRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::PutIntegration, request);
        }
 
        template<typename PutIntegrationRequestT = Model::PutIntegrationRequest>
        void PutIntegrationAsync(const PutIntegrationRequestT& request, const PutIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::PutIntegration, request, handler, context);
        }
 
        virtual Model::PutLogEventsOutcome PutLogEvents(const Model::PutLogEventsRequest& request) const;
 
        template<typename PutLogEventsRequestT = Model::PutLogEventsRequest>
        Model::PutLogEventsOutcomeCallable PutLogEventsCallable(const PutLogEventsRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::PutLogEvents, request);
        }
 
        template<typename PutLogEventsRequestT = Model::PutLogEventsRequest>
        void PutLogEventsAsync(const PutLogEventsRequestT& request, const PutLogEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::PutLogEvents, request, handler, context);
        }
 
        virtual Model::PutMetricFilterOutcome PutMetricFilter(const Model::PutMetricFilterRequest& request) const;
 
        template<typename PutMetricFilterRequestT = Model::PutMetricFilterRequest>
        Model::PutMetricFilterOutcomeCallable PutMetricFilterCallable(const PutMetricFilterRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::PutMetricFilter, request);
        }
 
        template<typename PutMetricFilterRequestT = Model::PutMetricFilterRequest>
        void PutMetricFilterAsync(const PutMetricFilterRequestT& request, const PutMetricFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::PutMetricFilter, request, handler, context);
        }
 
        virtual Model::PutQueryDefinitionOutcome PutQueryDefinition(const Model::PutQueryDefinitionRequest& request) const;
 
        template<typename PutQueryDefinitionRequestT = Model::PutQueryDefinitionRequest>
        Model::PutQueryDefinitionOutcomeCallable PutQueryDefinitionCallable(const PutQueryDefinitionRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::PutQueryDefinition, request);
        }
 
        template<typename PutQueryDefinitionRequestT = Model::PutQueryDefinitionRequest>
        void PutQueryDefinitionAsync(const PutQueryDefinitionRequestT& request, const PutQueryDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::PutQueryDefinition, 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(&CloudWatchLogsClient::PutResourcePolicy, request);
        }
 
        template<typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
        void PutResourcePolicyAsync(const PutResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const PutResourcePolicyRequestT& request = {}) const
        {
            return SubmitAsync(&CloudWatchLogsClient::PutResourcePolicy, request, handler, context);
        }
 
        virtual Model::PutRetentionPolicyOutcome PutRetentionPolicy(const Model::PutRetentionPolicyRequest& request) const;
 
        template<typename PutRetentionPolicyRequestT = Model::PutRetentionPolicyRequest>
        Model::PutRetentionPolicyOutcomeCallable PutRetentionPolicyCallable(const PutRetentionPolicyRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::PutRetentionPolicy, request);
        }
 
        template<typename PutRetentionPolicyRequestT = Model::PutRetentionPolicyRequest>
        void PutRetentionPolicyAsync(const PutRetentionPolicyRequestT& request, const PutRetentionPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::PutRetentionPolicy, request, handler, context);
        }
 
        virtual Model::PutSubscriptionFilterOutcome PutSubscriptionFilter(const Model::PutSubscriptionFilterRequest& request) const;
 
        template<typename PutSubscriptionFilterRequestT = Model::PutSubscriptionFilterRequest>
        Model::PutSubscriptionFilterOutcomeCallable PutSubscriptionFilterCallable(const PutSubscriptionFilterRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::PutSubscriptionFilter, request);
        }
 
        template<typename PutSubscriptionFilterRequestT = Model::PutSubscriptionFilterRequest>
        void PutSubscriptionFilterAsync(const PutSubscriptionFilterRequestT& request, const PutSubscriptionFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::PutSubscriptionFilter, request, handler, context);
        }
 
        virtual Model::PutTransformerOutcome PutTransformer(const Model::PutTransformerRequest& request) const;
 
        template<typename PutTransformerRequestT = Model::PutTransformerRequest>
        Model::PutTransformerOutcomeCallable PutTransformerCallable(const PutTransformerRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::PutTransformer, request);
        }
 
        template<typename PutTransformerRequestT = Model::PutTransformerRequest>
        void PutTransformerAsync(const PutTransformerRequestT& request, const PutTransformerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::PutTransformer, request, handler, context);
        }
 
        virtual Model::StartLiveTailOutcome StartLiveTail(Model::StartLiveTailRequest& request) const;
 
        template<typename StartLiveTailRequestT = Model::StartLiveTailRequest>
        Model::StartLiveTailOutcomeCallable StartLiveTailCallable(StartLiveTailRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::StartLiveTail, request);
        }
 
        template<typename StartLiveTailRequestT = Model::StartLiveTailRequest>
        void StartLiveTailAsync(StartLiveTailRequestT& request, const StartLiveTailResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::StartLiveTail, 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(&CloudWatchLogsClient::StartQuery, request);
        }
 
        template<typename StartQueryRequestT = Model::StartQueryRequest>
        void StartQueryAsync(const StartQueryRequestT& request, const StartQueryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::StartQuery, request, handler, context);
        }
 
        virtual Model::StopQueryOutcome StopQuery(const Model::StopQueryRequest& request) const;
 
        template<typename StopQueryRequestT = Model::StopQueryRequest>
        Model::StopQueryOutcomeCallable StopQueryCallable(const StopQueryRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::StopQuery, request);
        }
 
        template<typename StopQueryRequestT = Model::StopQueryRequest>
        void StopQueryAsync(const StopQueryRequestT& request, const StopQueryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::StopQuery, request, handler, context);
        }
 
        virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
        template<typename TagResourceRequestT = Model::TagResourceRequest>
        Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::TagResource, request);
        }
 
        template<typename TagResourceRequestT = Model::TagResourceRequest>
        void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::TagResource, request, handler, context);
        }
 
        virtual Model::TestMetricFilterOutcome TestMetricFilter(const Model::TestMetricFilterRequest& request) const;
 
        template<typename TestMetricFilterRequestT = Model::TestMetricFilterRequest>
        Model::TestMetricFilterOutcomeCallable TestMetricFilterCallable(const TestMetricFilterRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::TestMetricFilter, request);
        }
 
        template<typename TestMetricFilterRequestT = Model::TestMetricFilterRequest>
        void TestMetricFilterAsync(const TestMetricFilterRequestT& request, const TestMetricFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::TestMetricFilter, request, handler, context);
        }
 
        virtual Model::TestTransformerOutcome TestTransformer(const Model::TestTransformerRequest& request) const;
 
        template<typename TestTransformerRequestT = Model::TestTransformerRequest>
        Model::TestTransformerOutcomeCallable TestTransformerCallable(const TestTransformerRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::TestTransformer, request);
        }
 
        template<typename TestTransformerRequestT = Model::TestTransformerRequest>
        void TestTransformerAsync(const TestTransformerRequestT& request, const TestTransformerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::TestTransformer, request, handler, context);
        }
 
        virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::UntagResource, request);
        }
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateAnomalyOutcome UpdateAnomaly(const Model::UpdateAnomalyRequest& request) const;
 
        template<typename UpdateAnomalyRequestT = Model::UpdateAnomalyRequest>
        Model::UpdateAnomalyOutcomeCallable UpdateAnomalyCallable(const UpdateAnomalyRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::UpdateAnomaly, request);
        }
 
        template<typename UpdateAnomalyRequestT = Model::UpdateAnomalyRequest>
        void UpdateAnomalyAsync(const UpdateAnomalyRequestT& request, const UpdateAnomalyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::UpdateAnomaly, request, handler, context);
        }
 
        virtual Model::UpdateDeliveryConfigurationOutcome UpdateDeliveryConfiguration(const Model::UpdateDeliveryConfigurationRequest& request) const;
 
        template<typename UpdateDeliveryConfigurationRequestT = Model::UpdateDeliveryConfigurationRequest>
        Model::UpdateDeliveryConfigurationOutcomeCallable UpdateDeliveryConfigurationCallable(const UpdateDeliveryConfigurationRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::UpdateDeliveryConfiguration, request);
        }
 
        template<typename UpdateDeliveryConfigurationRequestT = Model::UpdateDeliveryConfigurationRequest>
        void UpdateDeliveryConfigurationAsync(const UpdateDeliveryConfigurationRequestT& request, const UpdateDeliveryConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::UpdateDeliveryConfiguration, request, handler, context);
        }
 
        virtual Model::UpdateLogAnomalyDetectorOutcome UpdateLogAnomalyDetector(const Model::UpdateLogAnomalyDetectorRequest& request) const;
 
        template<typename UpdateLogAnomalyDetectorRequestT = Model::UpdateLogAnomalyDetectorRequest>
        Model::UpdateLogAnomalyDetectorOutcomeCallable UpdateLogAnomalyDetectorCallable(const UpdateLogAnomalyDetectorRequestT& request) const
        {
            return SubmitCallable(&CloudWatchLogsClient::UpdateLogAnomalyDetector, request);
        }
 
        template<typename UpdateLogAnomalyDetectorRequestT = Model::UpdateLogAnomalyDetectorRequest>
        void UpdateLogAnomalyDetectorAsync(const UpdateLogAnomalyDetectorRequestT& request, const UpdateLogAnomalyDetectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchLogsClient::UpdateLogAnomalyDetector, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<CloudWatchLogsEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<CloudWatchLogsClient>;
      void init(const CloudWatchLogsClientConfiguration& clientConfiguration);
 
      CloudWatchLogsClientConfiguration m_clientConfiguration;
      std::shared_ptr<CloudWatchLogsEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace CloudWatchLogs
} // namespace Aws