CloudWatchLogsClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/logs/CloudWatchLogsPaginationBase.h>
#include <aws/logs/CloudWatchLogsServiceClientModel.h>
#include <aws/logs/CloudWatchLogsWaiter.h>
#include <aws/logs/CloudWatchLogs_EXPORTS.h>
 
namespace Aws {
namespace CloudWatchLogs {
class AWS_CLOUDWATCHLOGS_API CloudWatchLogsClient : public Aws::Client::AWSJsonClient,
                                                    public Aws::Client::ClientWithAsyncTemplateMethods<CloudWatchLogsClient>,
                                                    public CloudWatchLogsPaginationBase<CloudWatchLogsClient>,
                                                    public CloudWatchLogsWaiter<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::AssociateSourceToS3TableIntegrationOutcome AssociateSourceToS3TableIntegration(
      const Model::AssociateSourceToS3TableIntegrationRequest& request) const;
 
  template <typename AssociateSourceToS3TableIntegrationRequestT = Model::AssociateSourceToS3TableIntegrationRequest>
  Model::AssociateSourceToS3TableIntegrationOutcomeCallable AssociateSourceToS3TableIntegrationCallable(
      const AssociateSourceToS3TableIntegrationRequestT& request) const {
    return SubmitCallable(&CloudWatchLogsClient::AssociateSourceToS3TableIntegration, request);
  }
 
  template <typename AssociateSourceToS3TableIntegrationRequestT = Model::AssociateSourceToS3TableIntegrationRequest>
  void AssociateSourceToS3TableIntegrationAsync(const AssociateSourceToS3TableIntegrationRequestT& request,
                                                const AssociateSourceToS3TableIntegrationResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchLogsClient::AssociateSourceToS3TableIntegration, 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::CancelImportTaskOutcome CancelImportTask(const Model::CancelImportTaskRequest& request) const;
 
  template <typename CancelImportTaskRequestT = Model::CancelImportTaskRequest>
  Model::CancelImportTaskOutcomeCallable CancelImportTaskCallable(const CancelImportTaskRequestT& request) const {
    return SubmitCallable(&CloudWatchLogsClient::CancelImportTask, request);
  }
 
  template <typename CancelImportTaskRequestT = Model::CancelImportTaskRequest>
  void CancelImportTaskAsync(const CancelImportTaskRequestT& request, const CancelImportTaskResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchLogsClient::CancelImportTask, 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::CreateImportTaskOutcome CreateImportTask(const Model::CreateImportTaskRequest& request) const;
 
  template <typename CreateImportTaskRequestT = Model::CreateImportTaskRequest>
  Model::CreateImportTaskOutcomeCallable CreateImportTaskCallable(const CreateImportTaskRequestT& request) const {
    return SubmitCallable(&CloudWatchLogsClient::CreateImportTask, request);
  }
 
  template <typename CreateImportTaskRequestT = Model::CreateImportTaskRequest>
  void CreateImportTaskAsync(const CreateImportTaskRequestT& request, const CreateImportTaskResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchLogsClient::CreateImportTask, 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::CreateLookupTableOutcome CreateLookupTable(const Model::CreateLookupTableRequest& request) const;
 
  template <typename CreateLookupTableRequestT = Model::CreateLookupTableRequest>
  Model::CreateLookupTableOutcomeCallable CreateLookupTableCallable(const CreateLookupTableRequestT& request) const {
    return SubmitCallable(&CloudWatchLogsClient::CreateLookupTable, request);
  }
 
  template <typename CreateLookupTableRequestT = Model::CreateLookupTableRequest>
  void CreateLookupTableAsync(const CreateLookupTableRequestT& request, const CreateLookupTableResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchLogsClient::CreateLookupTable, request, handler, context);
  }
 
  virtual Model::CreateScheduledQueryOutcome CreateScheduledQuery(const Model::CreateScheduledQueryRequest& request) const;
 
  template <typename CreateScheduledQueryRequestT = Model::CreateScheduledQueryRequest>
  Model::CreateScheduledQueryOutcomeCallable CreateScheduledQueryCallable(const CreateScheduledQueryRequestT& request) const {
    return SubmitCallable(&CloudWatchLogsClient::CreateScheduledQuery, request);
  }
 
  template <typename CreateScheduledQueryRequestT = Model::CreateScheduledQueryRequest>
  void CreateScheduledQueryAsync(const CreateScheduledQueryRequestT& request, const CreateScheduledQueryResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchLogsClient::CreateScheduledQuery, 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::DeleteLookupTableOutcome DeleteLookupTable(const Model::DeleteLookupTableRequest& request) const;
 
  template <typename DeleteLookupTableRequestT = Model::DeleteLookupTableRequest>
  Model::DeleteLookupTableOutcomeCallable DeleteLookupTableCallable(const DeleteLookupTableRequestT& request) const {
    return SubmitCallable(&CloudWatchLogsClient::DeleteLookupTable, request);
  }
 
  template <typename DeleteLookupTableRequestT = Model::DeleteLookupTableRequest>
  void DeleteLookupTableAsync(const DeleteLookupTableRequestT& request, const DeleteLookupTableResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchLogsClient::DeleteLookupTable, 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::DeleteScheduledQueryOutcome DeleteScheduledQuery(const Model::DeleteScheduledQueryRequest& request) const;
 
  template <typename DeleteScheduledQueryRequestT = Model::DeleteScheduledQueryRequest>
  Model::DeleteScheduledQueryOutcomeCallable DeleteScheduledQueryCallable(const DeleteScheduledQueryRequestT& request) const {
    return SubmitCallable(&CloudWatchLogsClient::DeleteScheduledQuery, request);
  }
 
  template <typename DeleteScheduledQueryRequestT = Model::DeleteScheduledQueryRequest>
  void DeleteScheduledQueryAsync(const DeleteScheduledQueryRequestT& request, const DeleteScheduledQueryResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchLogsClient::DeleteScheduledQuery, 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::DeleteSyslogConfigurationOutcome DeleteSyslogConfiguration(const Model::DeleteSyslogConfigurationRequest& request) const;
 
  template <typename DeleteSyslogConfigurationRequestT = Model::DeleteSyslogConfigurationRequest>
  Model::DeleteSyslogConfigurationOutcomeCallable DeleteSyslogConfigurationCallable(
      const DeleteSyslogConfigurationRequestT& request) const {
    return SubmitCallable(&CloudWatchLogsClient::DeleteSyslogConfiguration, request);
  }
 
  template <typename DeleteSyslogConfigurationRequestT = Model::DeleteSyslogConfigurationRequest>
  void DeleteSyslogConfigurationAsync(const DeleteSyslogConfigurationRequestT& request,
                                      const DeleteSyslogConfigurationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchLogsClient::DeleteSyslogConfiguration, 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::DescribeImportTaskBatchesOutcome DescribeImportTaskBatches(const Model::DescribeImportTaskBatchesRequest& request) const;
 
  template <typename DescribeImportTaskBatchesRequestT = Model::DescribeImportTaskBatchesRequest>
  Model::DescribeImportTaskBatchesOutcomeCallable DescribeImportTaskBatchesCallable(
      const DescribeImportTaskBatchesRequestT& request) const {
    return SubmitCallable(&CloudWatchLogsClient::DescribeImportTaskBatches, request);
  }
 
  template <typename DescribeImportTaskBatchesRequestT = Model::DescribeImportTaskBatchesRequest>
  void DescribeImportTaskBatchesAsync(const DescribeImportTaskBatchesRequestT& request,
                                      const DescribeImportTaskBatchesResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchLogsClient::DescribeImportTaskBatches, request, handler, context);
  }
 
  virtual Model::DescribeImportTasksOutcome DescribeImportTasks(const Model::DescribeImportTasksRequest& request = {}) const;
 
  template <typename DescribeImportTasksRequestT = Model::DescribeImportTasksRequest>
  Model::DescribeImportTasksOutcomeCallable DescribeImportTasksCallable(const DescribeImportTasksRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchLogsClient::DescribeImportTasks, request);
  }
 
  template <typename DescribeImportTasksRequestT = Model::DescribeImportTasksRequest>
  void DescribeImportTasksAsync(const DescribeImportTasksResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const DescribeImportTasksRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchLogsClient::DescribeImportTasks, 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::DescribeLookupTablesOutcome DescribeLookupTables(const Model::DescribeLookupTablesRequest& request = {}) const;
 
  template <typename DescribeLookupTablesRequestT = Model::DescribeLookupTablesRequest>
  Model::DescribeLookupTablesOutcomeCallable DescribeLookupTablesCallable(const DescribeLookupTablesRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchLogsClient::DescribeLookupTables, request);
  }
 
  template <typename DescribeLookupTablesRequestT = Model::DescribeLookupTablesRequest>
  void DescribeLookupTablesAsync(const DescribeLookupTablesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const DescribeLookupTablesRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchLogsClient::DescribeLookupTables, 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::DisassociateSourceFromS3TableIntegrationOutcome DisassociateSourceFromS3TableIntegration(
      const Model::DisassociateSourceFromS3TableIntegrationRequest& request) const;
 
  template <typename DisassociateSourceFromS3TableIntegrationRequestT = Model::DisassociateSourceFromS3TableIntegrationRequest>
  Model::DisassociateSourceFromS3TableIntegrationOutcomeCallable DisassociateSourceFromS3TableIntegrationCallable(
      const DisassociateSourceFromS3TableIntegrationRequestT& request) const {
    return SubmitCallable(&CloudWatchLogsClient::DisassociateSourceFromS3TableIntegration, request);
  }
 
  template <typename DisassociateSourceFromS3TableIntegrationRequestT = Model::DisassociateSourceFromS3TableIntegrationRequest>
  void DisassociateSourceFromS3TableIntegrationAsync(
      const DisassociateSourceFromS3TableIntegrationRequestT& request,
      const DisassociateSourceFromS3TableIntegrationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchLogsClient::DisassociateSourceFromS3TableIntegration, 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::GetLogFieldsOutcome GetLogFields(const Model::GetLogFieldsRequest& request) const;
 
  template <typename GetLogFieldsRequestT = Model::GetLogFieldsRequest>
  Model::GetLogFieldsOutcomeCallable GetLogFieldsCallable(const GetLogFieldsRequestT& request) const {
    return SubmitCallable(&CloudWatchLogsClient::GetLogFields, request);
  }
 
  template <typename GetLogFieldsRequestT = Model::GetLogFieldsRequest>
  void GetLogFieldsAsync(const GetLogFieldsRequestT& request, const GetLogFieldsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchLogsClient::GetLogFields, 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::GetLogObjectOutcome GetLogObject(Model::GetLogObjectRequest& request) const;
 
  template <typename GetLogObjectRequestT = Model::GetLogObjectRequest>
  Model::GetLogObjectOutcomeCallable GetLogObjectCallable(GetLogObjectRequestT& request) const {
    return SubmitCallable(&CloudWatchLogsClient::GetLogObject, request);
  }
 
  template <typename GetLogObjectRequestT = Model::GetLogObjectRequest>
  void GetLogObjectAsync(GetLogObjectRequestT& request, const GetLogObjectResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchLogsClient::GetLogObject, 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::GetLookupTableOutcome GetLookupTable(const Model::GetLookupTableRequest& request) const;
 
  template <typename GetLookupTableRequestT = Model::GetLookupTableRequest>
  Model::GetLookupTableOutcomeCallable GetLookupTableCallable(const GetLookupTableRequestT& request) const {
    return SubmitCallable(&CloudWatchLogsClient::GetLookupTable, request);
  }
 
  template <typename GetLookupTableRequestT = Model::GetLookupTableRequest>
  void GetLookupTableAsync(const GetLookupTableRequestT& request, const GetLookupTableResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchLogsClient::GetLookupTable, 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::GetScheduledQueryOutcome GetScheduledQuery(const Model::GetScheduledQueryRequest& request) const;
 
  template <typename GetScheduledQueryRequestT = Model::GetScheduledQueryRequest>
  Model::GetScheduledQueryOutcomeCallable GetScheduledQueryCallable(const GetScheduledQueryRequestT& request) const {
    return SubmitCallable(&CloudWatchLogsClient::GetScheduledQuery, request);
  }
 
  template <typename GetScheduledQueryRequestT = Model::GetScheduledQueryRequest>
  void GetScheduledQueryAsync(const GetScheduledQueryRequestT& request, const GetScheduledQueryResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchLogsClient::GetScheduledQuery, request, handler, context);
  }
 
  virtual Model::GetScheduledQueryHistoryOutcome GetScheduledQueryHistory(const Model::GetScheduledQueryHistoryRequest& request) const;
 
  template <typename GetScheduledQueryHistoryRequestT = Model::GetScheduledQueryHistoryRequest>
  Model::GetScheduledQueryHistoryOutcomeCallable GetScheduledQueryHistoryCallable(const GetScheduledQueryHistoryRequestT& request) const {
    return SubmitCallable(&CloudWatchLogsClient::GetScheduledQueryHistory, request);
  }
 
  template <typename GetScheduledQueryHistoryRequestT = Model::GetScheduledQueryHistoryRequest>
  void GetScheduledQueryHistoryAsync(const GetScheduledQueryHistoryRequestT& request,
                                     const GetScheduledQueryHistoryResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchLogsClient::GetScheduledQueryHistory, request, handler, context);
  }
 
  virtual Model::GetStorageTierPolicyOutcome GetStorageTierPolicy(const Model::GetStorageTierPolicyRequest& request = {}) const;
 
  template <typename GetStorageTierPolicyRequestT = Model::GetStorageTierPolicyRequest>
  Model::GetStorageTierPolicyOutcomeCallable GetStorageTierPolicyCallable(const GetStorageTierPolicyRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchLogsClient::GetStorageTierPolicy, request);
  }
 
  template <typename GetStorageTierPolicyRequestT = Model::GetStorageTierPolicyRequest>
  void GetStorageTierPolicyAsync(const GetStorageTierPolicyResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const GetStorageTierPolicyRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchLogsClient::GetStorageTierPolicy, 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::ListAggregateLogGroupSummariesOutcome ListAggregateLogGroupSummaries(
      const Model::ListAggregateLogGroupSummariesRequest& request) const;
 
  template <typename ListAggregateLogGroupSummariesRequestT = Model::ListAggregateLogGroupSummariesRequest>
  Model::ListAggregateLogGroupSummariesOutcomeCallable ListAggregateLogGroupSummariesCallable(
      const ListAggregateLogGroupSummariesRequestT& request) const {
    return SubmitCallable(&CloudWatchLogsClient::ListAggregateLogGroupSummaries, request);
  }
 
  template <typename ListAggregateLogGroupSummariesRequestT = Model::ListAggregateLogGroupSummariesRequest>
  void ListAggregateLogGroupSummariesAsync(const ListAggregateLogGroupSummariesRequestT& request,
                                           const ListAggregateLogGroupSummariesResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchLogsClient::ListAggregateLogGroupSummaries, 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::ListScheduledQueriesOutcome ListScheduledQueries(const Model::ListScheduledQueriesRequest& request = {}) const;
 
  template <typename ListScheduledQueriesRequestT = Model::ListScheduledQueriesRequest>
  Model::ListScheduledQueriesOutcomeCallable ListScheduledQueriesCallable(const ListScheduledQueriesRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchLogsClient::ListScheduledQueries, request);
  }
 
  template <typename ListScheduledQueriesRequestT = Model::ListScheduledQueriesRequest>
  void ListScheduledQueriesAsync(const ListScheduledQueriesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListScheduledQueriesRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchLogsClient::ListScheduledQueries, request, handler, context);
  }
 
  virtual Model::ListSourcesForS3TableIntegrationOutcome ListSourcesForS3TableIntegration(
      const Model::ListSourcesForS3TableIntegrationRequest& request) const;
 
  template <typename ListSourcesForS3TableIntegrationRequestT = Model::ListSourcesForS3TableIntegrationRequest>
  Model::ListSourcesForS3TableIntegrationOutcomeCallable ListSourcesForS3TableIntegrationCallable(
      const ListSourcesForS3TableIntegrationRequestT& request) const {
    return SubmitCallable(&CloudWatchLogsClient::ListSourcesForS3TableIntegration, request);
  }
 
  template <typename ListSourcesForS3TableIntegrationRequestT = Model::ListSourcesForS3TableIntegrationRequest>
  void ListSourcesForS3TableIntegrationAsync(const ListSourcesForS3TableIntegrationRequestT& request,
                                             const ListSourcesForS3TableIntegrationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchLogsClient::ListSourcesForS3TableIntegration, request, handler, context);
  }
 
  virtual Model::ListSyslogConfigurationsOutcome ListSyslogConfigurations(const Model::ListSyslogConfigurationsRequest& request = {}) const;
 
  template <typename ListSyslogConfigurationsRequestT = Model::ListSyslogConfigurationsRequest>
  Model::ListSyslogConfigurationsOutcomeCallable ListSyslogConfigurationsCallable(
      const ListSyslogConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchLogsClient::ListSyslogConfigurations, request);
  }
 
  template <typename ListSyslogConfigurationsRequestT = Model::ListSyslogConfigurationsRequest>
  void ListSyslogConfigurationsAsync(const ListSyslogConfigurationsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListSyslogConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchLogsClient::ListSyslogConfigurations, 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::PutBearerTokenAuthenticationOutcome PutBearerTokenAuthentication(
      const Model::PutBearerTokenAuthenticationRequest& request) const;
 
  template <typename PutBearerTokenAuthenticationRequestT = Model::PutBearerTokenAuthenticationRequest>
  Model::PutBearerTokenAuthenticationOutcomeCallable PutBearerTokenAuthenticationCallable(
      const PutBearerTokenAuthenticationRequestT& request) const {
    return SubmitCallable(&CloudWatchLogsClient::PutBearerTokenAuthentication, request);
  }
 
  template <typename PutBearerTokenAuthenticationRequestT = Model::PutBearerTokenAuthenticationRequest>
  void PutBearerTokenAuthenticationAsync(const PutBearerTokenAuthenticationRequestT& request,
                                         const PutBearerTokenAuthenticationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchLogsClient::PutBearerTokenAuthentication, 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::PutLogGroupDeletionProtectionOutcome PutLogGroupDeletionProtection(
      const Model::PutLogGroupDeletionProtectionRequest& request) const;
 
  template <typename PutLogGroupDeletionProtectionRequestT = Model::PutLogGroupDeletionProtectionRequest>
  Model::PutLogGroupDeletionProtectionOutcomeCallable PutLogGroupDeletionProtectionCallable(
      const PutLogGroupDeletionProtectionRequestT& request) const {
    return SubmitCallable(&CloudWatchLogsClient::PutLogGroupDeletionProtection, request);
  }
 
  template <typename PutLogGroupDeletionProtectionRequestT = Model::PutLogGroupDeletionProtectionRequest>
  void PutLogGroupDeletionProtectionAsync(const PutLogGroupDeletionProtectionRequestT& request,
                                          const PutLogGroupDeletionProtectionResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchLogsClient::PutLogGroupDeletionProtection, 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::PutStorageTierPolicyOutcome PutStorageTierPolicy(const Model::PutStorageTierPolicyRequest& request) const;
 
  template <typename PutStorageTierPolicyRequestT = Model::PutStorageTierPolicyRequest>
  Model::PutStorageTierPolicyOutcomeCallable PutStorageTierPolicyCallable(const PutStorageTierPolicyRequestT& request) const {
    return SubmitCallable(&CloudWatchLogsClient::PutStorageTierPolicy, request);
  }
 
  template <typename PutStorageTierPolicyRequestT = Model::PutStorageTierPolicyRequest>
  void PutStorageTierPolicyAsync(const PutStorageTierPolicyRequestT& request, const PutStorageTierPolicyResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchLogsClient::PutStorageTierPolicy, 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::PutSyslogConfigurationOutcome PutSyslogConfiguration(const Model::PutSyslogConfigurationRequest& request) const;
 
  template <typename PutSyslogConfigurationRequestT = Model::PutSyslogConfigurationRequest>
  Model::PutSyslogConfigurationOutcomeCallable PutSyslogConfigurationCallable(const PutSyslogConfigurationRequestT& request) const {
    return SubmitCallable(&CloudWatchLogsClient::PutSyslogConfiguration, request);
  }
 
  template <typename PutSyslogConfigurationRequestT = Model::PutSyslogConfigurationRequest>
  void PutSyslogConfigurationAsync(const PutSyslogConfigurationRequestT& request,
                                   const PutSyslogConfigurationResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchLogsClient::PutSyslogConfiguration, 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);
  }
 
  virtual Model::UpdateLookupTableOutcome UpdateLookupTable(const Model::UpdateLookupTableRequest& request) const;
 
  template <typename UpdateLookupTableRequestT = Model::UpdateLookupTableRequest>
  Model::UpdateLookupTableOutcomeCallable UpdateLookupTableCallable(const UpdateLookupTableRequestT& request) const {
    return SubmitCallable(&CloudWatchLogsClient::UpdateLookupTable, request);
  }
 
  template <typename UpdateLookupTableRequestT = Model::UpdateLookupTableRequest>
  void UpdateLookupTableAsync(const UpdateLookupTableRequestT& request, const UpdateLookupTableResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchLogsClient::UpdateLookupTable, request, handler, context);
  }
 
  virtual Model::UpdateScheduledQueryOutcome UpdateScheduledQuery(const Model::UpdateScheduledQueryRequest& request) const;
 
  template <typename UpdateScheduledQueryRequestT = Model::UpdateScheduledQueryRequest>
  Model::UpdateScheduledQueryOutcomeCallable UpdateScheduledQueryCallable(const UpdateScheduledQueryRequestT& request) const {
    return SubmitCallable(&CloudWatchLogsClient::UpdateScheduledQuery, request);
  }
 
  template <typename UpdateScheduledQueryRequestT = Model::UpdateScheduledQueryRequest>
  void UpdateScheduledQueryAsync(const UpdateScheduledQueryRequestT& request, const UpdateScheduledQueryResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchLogsClient::UpdateScheduledQuery, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<CloudWatchLogsEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<CloudWatchLogsClient>;
  void init(const CloudWatchLogsClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, CloudWatchLogsError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  CloudWatchLogsClientConfiguration m_clientConfiguration;
  std::shared_ptr<CloudWatchLogsEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace CloudWatchLogs
}  // namespace Aws