ForecastServiceClient.h

 
#pragma once
#include <aws/forecast/ForecastService_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/forecast/ForecastServiceServiceClientModel.h>
 
namespace Aws
{
namespace ForecastService
{
  class AWS_FORECASTSERVICE_API ForecastServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<ForecastServiceClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef ForecastServiceClientConfiguration ClientConfigurationType;
      typedef ForecastServiceEndpointProvider EndpointProviderType;
 
        ForecastServiceClient(const Aws::ForecastService::ForecastServiceClientConfiguration& clientConfiguration = Aws::ForecastService::ForecastServiceClientConfiguration(),
                              std::shared_ptr<ForecastServiceEndpointProviderBase> endpointProvider = nullptr);
 
        ForecastServiceClient(const Aws::Auth::AWSCredentials& credentials,
                              std::shared_ptr<ForecastServiceEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::ForecastService::ForecastServiceClientConfiguration& clientConfiguration = Aws::ForecastService::ForecastServiceClientConfiguration());
 
        ForecastServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              std::shared_ptr<ForecastServiceEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::ForecastService::ForecastServiceClientConfiguration& clientConfiguration = Aws::ForecastService::ForecastServiceClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        ForecastServiceClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ForecastServiceClient(const Aws::Auth::AWSCredentials& credentials,
                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ForecastServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~ForecastServiceClient();
 
        virtual Model::CreateAutoPredictorOutcome CreateAutoPredictor(const Model::CreateAutoPredictorRequest& request) const;
 
        template<typename CreateAutoPredictorRequestT = Model::CreateAutoPredictorRequest>
        Model::CreateAutoPredictorOutcomeCallable CreateAutoPredictorCallable(const CreateAutoPredictorRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::CreateAutoPredictor, request);
        }
 
        template<typename CreateAutoPredictorRequestT = Model::CreateAutoPredictorRequest>
        void CreateAutoPredictorAsync(const CreateAutoPredictorRequestT& request, const CreateAutoPredictorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::CreateAutoPredictor, request, handler, context);
        }
 
        virtual Model::CreateDatasetOutcome CreateDataset(const Model::CreateDatasetRequest& request) const;
 
        template<typename CreateDatasetRequestT = Model::CreateDatasetRequest>
        Model::CreateDatasetOutcomeCallable CreateDatasetCallable(const CreateDatasetRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::CreateDataset, request);
        }
 
        template<typename CreateDatasetRequestT = Model::CreateDatasetRequest>
        void CreateDatasetAsync(const CreateDatasetRequestT& request, const CreateDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::CreateDataset, request, handler, context);
        }
 
        virtual Model::CreateDatasetGroupOutcome CreateDatasetGroup(const Model::CreateDatasetGroupRequest& request) const;
 
        template<typename CreateDatasetGroupRequestT = Model::CreateDatasetGroupRequest>
        Model::CreateDatasetGroupOutcomeCallable CreateDatasetGroupCallable(const CreateDatasetGroupRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::CreateDatasetGroup, request);
        }
 
        template<typename CreateDatasetGroupRequestT = Model::CreateDatasetGroupRequest>
        void CreateDatasetGroupAsync(const CreateDatasetGroupRequestT& request, const CreateDatasetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::CreateDatasetGroup, request, handler, context);
        }
 
        virtual Model::CreateDatasetImportJobOutcome CreateDatasetImportJob(const Model::CreateDatasetImportJobRequest& request) const;
 
        template<typename CreateDatasetImportJobRequestT = Model::CreateDatasetImportJobRequest>
        Model::CreateDatasetImportJobOutcomeCallable CreateDatasetImportJobCallable(const CreateDatasetImportJobRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::CreateDatasetImportJob, request);
        }
 
        template<typename CreateDatasetImportJobRequestT = Model::CreateDatasetImportJobRequest>
        void CreateDatasetImportJobAsync(const CreateDatasetImportJobRequestT& request, const CreateDatasetImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::CreateDatasetImportJob, request, handler, context);
        }
 
        virtual Model::CreateExplainabilityOutcome CreateExplainability(const Model::CreateExplainabilityRequest& request) const;
 
        template<typename CreateExplainabilityRequestT = Model::CreateExplainabilityRequest>
        Model::CreateExplainabilityOutcomeCallable CreateExplainabilityCallable(const CreateExplainabilityRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::CreateExplainability, request);
        }
 
        template<typename CreateExplainabilityRequestT = Model::CreateExplainabilityRequest>
        void CreateExplainabilityAsync(const CreateExplainabilityRequestT& request, const CreateExplainabilityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::CreateExplainability, request, handler, context);
        }
 
        virtual Model::CreateExplainabilityExportOutcome CreateExplainabilityExport(const Model::CreateExplainabilityExportRequest& request) const;
 
        template<typename CreateExplainabilityExportRequestT = Model::CreateExplainabilityExportRequest>
        Model::CreateExplainabilityExportOutcomeCallable CreateExplainabilityExportCallable(const CreateExplainabilityExportRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::CreateExplainabilityExport, request);
        }
 
        template<typename CreateExplainabilityExportRequestT = Model::CreateExplainabilityExportRequest>
        void CreateExplainabilityExportAsync(const CreateExplainabilityExportRequestT& request, const CreateExplainabilityExportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::CreateExplainabilityExport, request, handler, context);
        }
 
        virtual Model::CreateForecastOutcome CreateForecast(const Model::CreateForecastRequest& request) const;
 
        template<typename CreateForecastRequestT = Model::CreateForecastRequest>
        Model::CreateForecastOutcomeCallable CreateForecastCallable(const CreateForecastRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::CreateForecast, request);
        }
 
        template<typename CreateForecastRequestT = Model::CreateForecastRequest>
        void CreateForecastAsync(const CreateForecastRequestT& request, const CreateForecastResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::CreateForecast, request, handler, context);
        }
 
        virtual Model::CreateForecastExportJobOutcome CreateForecastExportJob(const Model::CreateForecastExportJobRequest& request) const;
 
        template<typename CreateForecastExportJobRequestT = Model::CreateForecastExportJobRequest>
        Model::CreateForecastExportJobOutcomeCallable CreateForecastExportJobCallable(const CreateForecastExportJobRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::CreateForecastExportJob, request);
        }
 
        template<typename CreateForecastExportJobRequestT = Model::CreateForecastExportJobRequest>
        void CreateForecastExportJobAsync(const CreateForecastExportJobRequestT& request, const CreateForecastExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::CreateForecastExportJob, request, handler, context);
        }
 
        virtual Model::CreateMonitorOutcome CreateMonitor(const Model::CreateMonitorRequest& request) const;
 
        template<typename CreateMonitorRequestT = Model::CreateMonitorRequest>
        Model::CreateMonitorOutcomeCallable CreateMonitorCallable(const CreateMonitorRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::CreateMonitor, request);
        }
 
        template<typename CreateMonitorRequestT = Model::CreateMonitorRequest>
        void CreateMonitorAsync(const CreateMonitorRequestT& request, const CreateMonitorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::CreateMonitor, request, handler, context);
        }
 
        virtual Model::CreatePredictorOutcome CreatePredictor(const Model::CreatePredictorRequest& request) const;
 
        template<typename CreatePredictorRequestT = Model::CreatePredictorRequest>
        Model::CreatePredictorOutcomeCallable CreatePredictorCallable(const CreatePredictorRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::CreatePredictor, request);
        }
 
        template<typename CreatePredictorRequestT = Model::CreatePredictorRequest>
        void CreatePredictorAsync(const CreatePredictorRequestT& request, const CreatePredictorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::CreatePredictor, request, handler, context);
        }
 
        virtual Model::CreatePredictorBacktestExportJobOutcome CreatePredictorBacktestExportJob(const Model::CreatePredictorBacktestExportJobRequest& request) const;
 
        template<typename CreatePredictorBacktestExportJobRequestT = Model::CreatePredictorBacktestExportJobRequest>
        Model::CreatePredictorBacktestExportJobOutcomeCallable CreatePredictorBacktestExportJobCallable(const CreatePredictorBacktestExportJobRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::CreatePredictorBacktestExportJob, request);
        }
 
        template<typename CreatePredictorBacktestExportJobRequestT = Model::CreatePredictorBacktestExportJobRequest>
        void CreatePredictorBacktestExportJobAsync(const CreatePredictorBacktestExportJobRequestT& request, const CreatePredictorBacktestExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::CreatePredictorBacktestExportJob, request, handler, context);
        }
 
        virtual Model::CreateWhatIfAnalysisOutcome CreateWhatIfAnalysis(const Model::CreateWhatIfAnalysisRequest& request) const;
 
        template<typename CreateWhatIfAnalysisRequestT = Model::CreateWhatIfAnalysisRequest>
        Model::CreateWhatIfAnalysisOutcomeCallable CreateWhatIfAnalysisCallable(const CreateWhatIfAnalysisRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::CreateWhatIfAnalysis, request);
        }
 
        template<typename CreateWhatIfAnalysisRequestT = Model::CreateWhatIfAnalysisRequest>
        void CreateWhatIfAnalysisAsync(const CreateWhatIfAnalysisRequestT& request, const CreateWhatIfAnalysisResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::CreateWhatIfAnalysis, request, handler, context);
        }
 
        virtual Model::CreateWhatIfForecastOutcome CreateWhatIfForecast(const Model::CreateWhatIfForecastRequest& request) const;
 
        template<typename CreateWhatIfForecastRequestT = Model::CreateWhatIfForecastRequest>
        Model::CreateWhatIfForecastOutcomeCallable CreateWhatIfForecastCallable(const CreateWhatIfForecastRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::CreateWhatIfForecast, request);
        }
 
        template<typename CreateWhatIfForecastRequestT = Model::CreateWhatIfForecastRequest>
        void CreateWhatIfForecastAsync(const CreateWhatIfForecastRequestT& request, const CreateWhatIfForecastResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::CreateWhatIfForecast, request, handler, context);
        }
 
        virtual Model::CreateWhatIfForecastExportOutcome CreateWhatIfForecastExport(const Model::CreateWhatIfForecastExportRequest& request) const;
 
        template<typename CreateWhatIfForecastExportRequestT = Model::CreateWhatIfForecastExportRequest>
        Model::CreateWhatIfForecastExportOutcomeCallable CreateWhatIfForecastExportCallable(const CreateWhatIfForecastExportRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::CreateWhatIfForecastExport, request);
        }
 
        template<typename CreateWhatIfForecastExportRequestT = Model::CreateWhatIfForecastExportRequest>
        void CreateWhatIfForecastExportAsync(const CreateWhatIfForecastExportRequestT& request, const CreateWhatIfForecastExportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::CreateWhatIfForecastExport, request, handler, context);
        }
 
        virtual Model::DeleteDatasetOutcome DeleteDataset(const Model::DeleteDatasetRequest& request) const;
 
        template<typename DeleteDatasetRequestT = Model::DeleteDatasetRequest>
        Model::DeleteDatasetOutcomeCallable DeleteDatasetCallable(const DeleteDatasetRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DeleteDataset, request);
        }
 
        template<typename DeleteDatasetRequestT = Model::DeleteDatasetRequest>
        void DeleteDatasetAsync(const DeleteDatasetRequestT& request, const DeleteDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DeleteDataset, request, handler, context);
        }
 
        virtual Model::DeleteDatasetGroupOutcome DeleteDatasetGroup(const Model::DeleteDatasetGroupRequest& request) const;
 
        template<typename DeleteDatasetGroupRequestT = Model::DeleteDatasetGroupRequest>
        Model::DeleteDatasetGroupOutcomeCallable DeleteDatasetGroupCallable(const DeleteDatasetGroupRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DeleteDatasetGroup, request);
        }
 
        template<typename DeleteDatasetGroupRequestT = Model::DeleteDatasetGroupRequest>
        void DeleteDatasetGroupAsync(const DeleteDatasetGroupRequestT& request, const DeleteDatasetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DeleteDatasetGroup, request, handler, context);
        }
 
        virtual Model::DeleteDatasetImportJobOutcome DeleteDatasetImportJob(const Model::DeleteDatasetImportJobRequest& request) const;
 
        template<typename DeleteDatasetImportJobRequestT = Model::DeleteDatasetImportJobRequest>
        Model::DeleteDatasetImportJobOutcomeCallable DeleteDatasetImportJobCallable(const DeleteDatasetImportJobRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DeleteDatasetImportJob, request);
        }
 
        template<typename DeleteDatasetImportJobRequestT = Model::DeleteDatasetImportJobRequest>
        void DeleteDatasetImportJobAsync(const DeleteDatasetImportJobRequestT& request, const DeleteDatasetImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DeleteDatasetImportJob, request, handler, context);
        }
 
        virtual Model::DeleteExplainabilityOutcome DeleteExplainability(const Model::DeleteExplainabilityRequest& request) const;
 
        template<typename DeleteExplainabilityRequestT = Model::DeleteExplainabilityRequest>
        Model::DeleteExplainabilityOutcomeCallable DeleteExplainabilityCallable(const DeleteExplainabilityRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DeleteExplainability, request);
        }
 
        template<typename DeleteExplainabilityRequestT = Model::DeleteExplainabilityRequest>
        void DeleteExplainabilityAsync(const DeleteExplainabilityRequestT& request, const DeleteExplainabilityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DeleteExplainability, request, handler, context);
        }
 
        virtual Model::DeleteExplainabilityExportOutcome DeleteExplainabilityExport(const Model::DeleteExplainabilityExportRequest& request) const;
 
        template<typename DeleteExplainabilityExportRequestT = Model::DeleteExplainabilityExportRequest>
        Model::DeleteExplainabilityExportOutcomeCallable DeleteExplainabilityExportCallable(const DeleteExplainabilityExportRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DeleteExplainabilityExport, request);
        }
 
        template<typename DeleteExplainabilityExportRequestT = Model::DeleteExplainabilityExportRequest>
        void DeleteExplainabilityExportAsync(const DeleteExplainabilityExportRequestT& request, const DeleteExplainabilityExportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DeleteExplainabilityExport, request, handler, context);
        }
 
        virtual Model::DeleteForecastOutcome DeleteForecast(const Model::DeleteForecastRequest& request) const;
 
        template<typename DeleteForecastRequestT = Model::DeleteForecastRequest>
        Model::DeleteForecastOutcomeCallable DeleteForecastCallable(const DeleteForecastRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DeleteForecast, request);
        }
 
        template<typename DeleteForecastRequestT = Model::DeleteForecastRequest>
        void DeleteForecastAsync(const DeleteForecastRequestT& request, const DeleteForecastResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DeleteForecast, request, handler, context);
        }
 
        virtual Model::DeleteForecastExportJobOutcome DeleteForecastExportJob(const Model::DeleteForecastExportJobRequest& request) const;
 
        template<typename DeleteForecastExportJobRequestT = Model::DeleteForecastExportJobRequest>
        Model::DeleteForecastExportJobOutcomeCallable DeleteForecastExportJobCallable(const DeleteForecastExportJobRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DeleteForecastExportJob, request);
        }
 
        template<typename DeleteForecastExportJobRequestT = Model::DeleteForecastExportJobRequest>
        void DeleteForecastExportJobAsync(const DeleteForecastExportJobRequestT& request, const DeleteForecastExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DeleteForecastExportJob, request, handler, context);
        }
 
        virtual Model::DeleteMonitorOutcome DeleteMonitor(const Model::DeleteMonitorRequest& request) const;
 
        template<typename DeleteMonitorRequestT = Model::DeleteMonitorRequest>
        Model::DeleteMonitorOutcomeCallable DeleteMonitorCallable(const DeleteMonitorRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DeleteMonitor, request);
        }
 
        template<typename DeleteMonitorRequestT = Model::DeleteMonitorRequest>
        void DeleteMonitorAsync(const DeleteMonitorRequestT& request, const DeleteMonitorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DeleteMonitor, request, handler, context);
        }
 
        virtual Model::DeletePredictorOutcome DeletePredictor(const Model::DeletePredictorRequest& request) const;
 
        template<typename DeletePredictorRequestT = Model::DeletePredictorRequest>
        Model::DeletePredictorOutcomeCallable DeletePredictorCallable(const DeletePredictorRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DeletePredictor, request);
        }
 
        template<typename DeletePredictorRequestT = Model::DeletePredictorRequest>
        void DeletePredictorAsync(const DeletePredictorRequestT& request, const DeletePredictorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DeletePredictor, request, handler, context);
        }
 
        virtual Model::DeletePredictorBacktestExportJobOutcome DeletePredictorBacktestExportJob(const Model::DeletePredictorBacktestExportJobRequest& request) const;
 
        template<typename DeletePredictorBacktestExportJobRequestT = Model::DeletePredictorBacktestExportJobRequest>
        Model::DeletePredictorBacktestExportJobOutcomeCallable DeletePredictorBacktestExportJobCallable(const DeletePredictorBacktestExportJobRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DeletePredictorBacktestExportJob, request);
        }
 
        template<typename DeletePredictorBacktestExportJobRequestT = Model::DeletePredictorBacktestExportJobRequest>
        void DeletePredictorBacktestExportJobAsync(const DeletePredictorBacktestExportJobRequestT& request, const DeletePredictorBacktestExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DeletePredictorBacktestExportJob, request, handler, context);
        }
 
        virtual Model::DeleteResourceTreeOutcome DeleteResourceTree(const Model::DeleteResourceTreeRequest& request) const;
 
        template<typename DeleteResourceTreeRequestT = Model::DeleteResourceTreeRequest>
        Model::DeleteResourceTreeOutcomeCallable DeleteResourceTreeCallable(const DeleteResourceTreeRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DeleteResourceTree, request);
        }
 
        template<typename DeleteResourceTreeRequestT = Model::DeleteResourceTreeRequest>
        void DeleteResourceTreeAsync(const DeleteResourceTreeRequestT& request, const DeleteResourceTreeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DeleteResourceTree, request, handler, context);
        }
 
        virtual Model::DeleteWhatIfAnalysisOutcome DeleteWhatIfAnalysis(const Model::DeleteWhatIfAnalysisRequest& request) const;
 
        template<typename DeleteWhatIfAnalysisRequestT = Model::DeleteWhatIfAnalysisRequest>
        Model::DeleteWhatIfAnalysisOutcomeCallable DeleteWhatIfAnalysisCallable(const DeleteWhatIfAnalysisRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DeleteWhatIfAnalysis, request);
        }
 
        template<typename DeleteWhatIfAnalysisRequestT = Model::DeleteWhatIfAnalysisRequest>
        void DeleteWhatIfAnalysisAsync(const DeleteWhatIfAnalysisRequestT& request, const DeleteWhatIfAnalysisResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DeleteWhatIfAnalysis, request, handler, context);
        }
 
        virtual Model::DeleteWhatIfForecastOutcome DeleteWhatIfForecast(const Model::DeleteWhatIfForecastRequest& request) const;
 
        template<typename DeleteWhatIfForecastRequestT = Model::DeleteWhatIfForecastRequest>
        Model::DeleteWhatIfForecastOutcomeCallable DeleteWhatIfForecastCallable(const DeleteWhatIfForecastRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DeleteWhatIfForecast, request);
        }
 
        template<typename DeleteWhatIfForecastRequestT = Model::DeleteWhatIfForecastRequest>
        void DeleteWhatIfForecastAsync(const DeleteWhatIfForecastRequestT& request, const DeleteWhatIfForecastResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DeleteWhatIfForecast, request, handler, context);
        }
 
        virtual Model::DeleteWhatIfForecastExportOutcome DeleteWhatIfForecastExport(const Model::DeleteWhatIfForecastExportRequest& request) const;
 
        template<typename DeleteWhatIfForecastExportRequestT = Model::DeleteWhatIfForecastExportRequest>
        Model::DeleteWhatIfForecastExportOutcomeCallable DeleteWhatIfForecastExportCallable(const DeleteWhatIfForecastExportRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DeleteWhatIfForecastExport, request);
        }
 
        template<typename DeleteWhatIfForecastExportRequestT = Model::DeleteWhatIfForecastExportRequest>
        void DeleteWhatIfForecastExportAsync(const DeleteWhatIfForecastExportRequestT& request, const DeleteWhatIfForecastExportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DeleteWhatIfForecastExport, request, handler, context);
        }
 
        virtual Model::DescribeAutoPredictorOutcome DescribeAutoPredictor(const Model::DescribeAutoPredictorRequest& request) const;
 
        template<typename DescribeAutoPredictorRequestT = Model::DescribeAutoPredictorRequest>
        Model::DescribeAutoPredictorOutcomeCallable DescribeAutoPredictorCallable(const DescribeAutoPredictorRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DescribeAutoPredictor, request);
        }
 
        template<typename DescribeAutoPredictorRequestT = Model::DescribeAutoPredictorRequest>
        void DescribeAutoPredictorAsync(const DescribeAutoPredictorRequestT& request, const DescribeAutoPredictorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DescribeAutoPredictor, request, handler, context);
        }
 
        virtual Model::DescribeDatasetOutcome DescribeDataset(const Model::DescribeDatasetRequest& request) const;
 
        template<typename DescribeDatasetRequestT = Model::DescribeDatasetRequest>
        Model::DescribeDatasetOutcomeCallable DescribeDatasetCallable(const DescribeDatasetRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DescribeDataset, request);
        }
 
        template<typename DescribeDatasetRequestT = Model::DescribeDatasetRequest>
        void DescribeDatasetAsync(const DescribeDatasetRequestT& request, const DescribeDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DescribeDataset, request, handler, context);
        }
 
        virtual Model::DescribeDatasetGroupOutcome DescribeDatasetGroup(const Model::DescribeDatasetGroupRequest& request) const;
 
        template<typename DescribeDatasetGroupRequestT = Model::DescribeDatasetGroupRequest>
        Model::DescribeDatasetGroupOutcomeCallable DescribeDatasetGroupCallable(const DescribeDatasetGroupRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DescribeDatasetGroup, request);
        }
 
        template<typename DescribeDatasetGroupRequestT = Model::DescribeDatasetGroupRequest>
        void DescribeDatasetGroupAsync(const DescribeDatasetGroupRequestT& request, const DescribeDatasetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DescribeDatasetGroup, request, handler, context);
        }
 
        virtual Model::DescribeDatasetImportJobOutcome DescribeDatasetImportJob(const Model::DescribeDatasetImportJobRequest& request) const;
 
        template<typename DescribeDatasetImportJobRequestT = Model::DescribeDatasetImportJobRequest>
        Model::DescribeDatasetImportJobOutcomeCallable DescribeDatasetImportJobCallable(const DescribeDatasetImportJobRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DescribeDatasetImportJob, request);
        }
 
        template<typename DescribeDatasetImportJobRequestT = Model::DescribeDatasetImportJobRequest>
        void DescribeDatasetImportJobAsync(const DescribeDatasetImportJobRequestT& request, const DescribeDatasetImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DescribeDatasetImportJob, request, handler, context);
        }
 
        virtual Model::DescribeExplainabilityOutcome DescribeExplainability(const Model::DescribeExplainabilityRequest& request) const;
 
        template<typename DescribeExplainabilityRequestT = Model::DescribeExplainabilityRequest>
        Model::DescribeExplainabilityOutcomeCallable DescribeExplainabilityCallable(const DescribeExplainabilityRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DescribeExplainability, request);
        }
 
        template<typename DescribeExplainabilityRequestT = Model::DescribeExplainabilityRequest>
        void DescribeExplainabilityAsync(const DescribeExplainabilityRequestT& request, const DescribeExplainabilityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DescribeExplainability, request, handler, context);
        }
 
        virtual Model::DescribeExplainabilityExportOutcome DescribeExplainabilityExport(const Model::DescribeExplainabilityExportRequest& request) const;
 
        template<typename DescribeExplainabilityExportRequestT = Model::DescribeExplainabilityExportRequest>
        Model::DescribeExplainabilityExportOutcomeCallable DescribeExplainabilityExportCallable(const DescribeExplainabilityExportRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DescribeExplainabilityExport, request);
        }
 
        template<typename DescribeExplainabilityExportRequestT = Model::DescribeExplainabilityExportRequest>
        void DescribeExplainabilityExportAsync(const DescribeExplainabilityExportRequestT& request, const DescribeExplainabilityExportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DescribeExplainabilityExport, request, handler, context);
        }
 
        virtual Model::DescribeForecastOutcome DescribeForecast(const Model::DescribeForecastRequest& request) const;
 
        template<typename DescribeForecastRequestT = Model::DescribeForecastRequest>
        Model::DescribeForecastOutcomeCallable DescribeForecastCallable(const DescribeForecastRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DescribeForecast, request);
        }
 
        template<typename DescribeForecastRequestT = Model::DescribeForecastRequest>
        void DescribeForecastAsync(const DescribeForecastRequestT& request, const DescribeForecastResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DescribeForecast, request, handler, context);
        }
 
        virtual Model::DescribeForecastExportJobOutcome DescribeForecastExportJob(const Model::DescribeForecastExportJobRequest& request) const;
 
        template<typename DescribeForecastExportJobRequestT = Model::DescribeForecastExportJobRequest>
        Model::DescribeForecastExportJobOutcomeCallable DescribeForecastExportJobCallable(const DescribeForecastExportJobRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DescribeForecastExportJob, request);
        }
 
        template<typename DescribeForecastExportJobRequestT = Model::DescribeForecastExportJobRequest>
        void DescribeForecastExportJobAsync(const DescribeForecastExportJobRequestT& request, const DescribeForecastExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DescribeForecastExportJob, request, handler, context);
        }
 
        virtual Model::DescribeMonitorOutcome DescribeMonitor(const Model::DescribeMonitorRequest& request) const;
 
        template<typename DescribeMonitorRequestT = Model::DescribeMonitorRequest>
        Model::DescribeMonitorOutcomeCallable DescribeMonitorCallable(const DescribeMonitorRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DescribeMonitor, request);
        }
 
        template<typename DescribeMonitorRequestT = Model::DescribeMonitorRequest>
        void DescribeMonitorAsync(const DescribeMonitorRequestT& request, const DescribeMonitorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DescribeMonitor, request, handler, context);
        }
 
        virtual Model::DescribePredictorOutcome DescribePredictor(const Model::DescribePredictorRequest& request) const;
 
        template<typename DescribePredictorRequestT = Model::DescribePredictorRequest>
        Model::DescribePredictorOutcomeCallable DescribePredictorCallable(const DescribePredictorRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DescribePredictor, request);
        }
 
        template<typename DescribePredictorRequestT = Model::DescribePredictorRequest>
        void DescribePredictorAsync(const DescribePredictorRequestT& request, const DescribePredictorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DescribePredictor, request, handler, context);
        }
 
        virtual Model::DescribePredictorBacktestExportJobOutcome DescribePredictorBacktestExportJob(const Model::DescribePredictorBacktestExportJobRequest& request) const;
 
        template<typename DescribePredictorBacktestExportJobRequestT = Model::DescribePredictorBacktestExportJobRequest>
        Model::DescribePredictorBacktestExportJobOutcomeCallable DescribePredictorBacktestExportJobCallable(const DescribePredictorBacktestExportJobRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DescribePredictorBacktestExportJob, request);
        }
 
        template<typename DescribePredictorBacktestExportJobRequestT = Model::DescribePredictorBacktestExportJobRequest>
        void DescribePredictorBacktestExportJobAsync(const DescribePredictorBacktestExportJobRequestT& request, const DescribePredictorBacktestExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DescribePredictorBacktestExportJob, request, handler, context);
        }
 
        virtual Model::DescribeWhatIfAnalysisOutcome DescribeWhatIfAnalysis(const Model::DescribeWhatIfAnalysisRequest& request) const;
 
        template<typename DescribeWhatIfAnalysisRequestT = Model::DescribeWhatIfAnalysisRequest>
        Model::DescribeWhatIfAnalysisOutcomeCallable DescribeWhatIfAnalysisCallable(const DescribeWhatIfAnalysisRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DescribeWhatIfAnalysis, request);
        }
 
        template<typename DescribeWhatIfAnalysisRequestT = Model::DescribeWhatIfAnalysisRequest>
        void DescribeWhatIfAnalysisAsync(const DescribeWhatIfAnalysisRequestT& request, const DescribeWhatIfAnalysisResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DescribeWhatIfAnalysis, request, handler, context);
        }
 
        virtual Model::DescribeWhatIfForecastOutcome DescribeWhatIfForecast(const Model::DescribeWhatIfForecastRequest& request) const;
 
        template<typename DescribeWhatIfForecastRequestT = Model::DescribeWhatIfForecastRequest>
        Model::DescribeWhatIfForecastOutcomeCallable DescribeWhatIfForecastCallable(const DescribeWhatIfForecastRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DescribeWhatIfForecast, request);
        }
 
        template<typename DescribeWhatIfForecastRequestT = Model::DescribeWhatIfForecastRequest>
        void DescribeWhatIfForecastAsync(const DescribeWhatIfForecastRequestT& request, const DescribeWhatIfForecastResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DescribeWhatIfForecast, request, handler, context);
        }
 
        virtual Model::DescribeWhatIfForecastExportOutcome DescribeWhatIfForecastExport(const Model::DescribeWhatIfForecastExportRequest& request) const;
 
        template<typename DescribeWhatIfForecastExportRequestT = Model::DescribeWhatIfForecastExportRequest>
        Model::DescribeWhatIfForecastExportOutcomeCallable DescribeWhatIfForecastExportCallable(const DescribeWhatIfForecastExportRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::DescribeWhatIfForecastExport, request);
        }
 
        template<typename DescribeWhatIfForecastExportRequestT = Model::DescribeWhatIfForecastExportRequest>
        void DescribeWhatIfForecastExportAsync(const DescribeWhatIfForecastExportRequestT& request, const DescribeWhatIfForecastExportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::DescribeWhatIfForecastExport, request, handler, context);
        }
 
        virtual Model::GetAccuracyMetricsOutcome GetAccuracyMetrics(const Model::GetAccuracyMetricsRequest& request) const;
 
        template<typename GetAccuracyMetricsRequestT = Model::GetAccuracyMetricsRequest>
        Model::GetAccuracyMetricsOutcomeCallable GetAccuracyMetricsCallable(const GetAccuracyMetricsRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::GetAccuracyMetrics, request);
        }
 
        template<typename GetAccuracyMetricsRequestT = Model::GetAccuracyMetricsRequest>
        void GetAccuracyMetricsAsync(const GetAccuracyMetricsRequestT& request, const GetAccuracyMetricsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::GetAccuracyMetrics, request, handler, context);
        }
 
        virtual Model::ListDatasetGroupsOutcome ListDatasetGroups(const Model::ListDatasetGroupsRequest& request = {}) const;
 
        template<typename ListDatasetGroupsRequestT = Model::ListDatasetGroupsRequest>
        Model::ListDatasetGroupsOutcomeCallable ListDatasetGroupsCallable(const ListDatasetGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&ForecastServiceClient::ListDatasetGroups, request);
        }
 
        template<typename ListDatasetGroupsRequestT = Model::ListDatasetGroupsRequest>
        void ListDatasetGroupsAsync(const ListDatasetGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDatasetGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&ForecastServiceClient::ListDatasetGroups, request, handler, context);
        }
 
        virtual Model::ListDatasetImportJobsOutcome ListDatasetImportJobs(const Model::ListDatasetImportJobsRequest& request = {}) const;
 
        template<typename ListDatasetImportJobsRequestT = Model::ListDatasetImportJobsRequest>
        Model::ListDatasetImportJobsOutcomeCallable ListDatasetImportJobsCallable(const ListDatasetImportJobsRequestT& request = {}) const
        {
            return SubmitCallable(&ForecastServiceClient::ListDatasetImportJobs, request);
        }
 
        template<typename ListDatasetImportJobsRequestT = Model::ListDatasetImportJobsRequest>
        void ListDatasetImportJobsAsync(const ListDatasetImportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDatasetImportJobsRequestT& request = {}) const
        {
            return SubmitAsync(&ForecastServiceClient::ListDatasetImportJobs, request, handler, context);
        }
 
        virtual Model::ListDatasetsOutcome ListDatasets(const Model::ListDatasetsRequest& request = {}) const;
 
        template<typename ListDatasetsRequestT = Model::ListDatasetsRequest>
        Model::ListDatasetsOutcomeCallable ListDatasetsCallable(const ListDatasetsRequestT& request = {}) const
        {
            return SubmitCallable(&ForecastServiceClient::ListDatasets, request);
        }
 
        template<typename ListDatasetsRequestT = Model::ListDatasetsRequest>
        void ListDatasetsAsync(const ListDatasetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDatasetsRequestT& request = {}) const
        {
            return SubmitAsync(&ForecastServiceClient::ListDatasets, request, handler, context);
        }
 
        virtual Model::ListExplainabilitiesOutcome ListExplainabilities(const Model::ListExplainabilitiesRequest& request = {}) const;
 
        template<typename ListExplainabilitiesRequestT = Model::ListExplainabilitiesRequest>
        Model::ListExplainabilitiesOutcomeCallable ListExplainabilitiesCallable(const ListExplainabilitiesRequestT& request = {}) const
        {
            return SubmitCallable(&ForecastServiceClient::ListExplainabilities, request);
        }
 
        template<typename ListExplainabilitiesRequestT = Model::ListExplainabilitiesRequest>
        void ListExplainabilitiesAsync(const ListExplainabilitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListExplainabilitiesRequestT& request = {}) const
        {
            return SubmitAsync(&ForecastServiceClient::ListExplainabilities, request, handler, context);
        }
 
        virtual Model::ListExplainabilityExportsOutcome ListExplainabilityExports(const Model::ListExplainabilityExportsRequest& request = {}) const;
 
        template<typename ListExplainabilityExportsRequestT = Model::ListExplainabilityExportsRequest>
        Model::ListExplainabilityExportsOutcomeCallable ListExplainabilityExportsCallable(const ListExplainabilityExportsRequestT& request = {}) const
        {
            return SubmitCallable(&ForecastServiceClient::ListExplainabilityExports, request);
        }
 
        template<typename ListExplainabilityExportsRequestT = Model::ListExplainabilityExportsRequest>
        void ListExplainabilityExportsAsync(const ListExplainabilityExportsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListExplainabilityExportsRequestT& request = {}) const
        {
            return SubmitAsync(&ForecastServiceClient::ListExplainabilityExports, request, handler, context);
        }
 
        virtual Model::ListForecastExportJobsOutcome ListForecastExportJobs(const Model::ListForecastExportJobsRequest& request = {}) const;
 
        template<typename ListForecastExportJobsRequestT = Model::ListForecastExportJobsRequest>
        Model::ListForecastExportJobsOutcomeCallable ListForecastExportJobsCallable(const ListForecastExportJobsRequestT& request = {}) const
        {
            return SubmitCallable(&ForecastServiceClient::ListForecastExportJobs, request);
        }
 
        template<typename ListForecastExportJobsRequestT = Model::ListForecastExportJobsRequest>
        void ListForecastExportJobsAsync(const ListForecastExportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListForecastExportJobsRequestT& request = {}) const
        {
            return SubmitAsync(&ForecastServiceClient::ListForecastExportJobs, request, handler, context);
        }
 
        virtual Model::ListForecastsOutcome ListForecasts(const Model::ListForecastsRequest& request = {}) const;
 
        template<typename ListForecastsRequestT = Model::ListForecastsRequest>
        Model::ListForecastsOutcomeCallable ListForecastsCallable(const ListForecastsRequestT& request = {}) const
        {
            return SubmitCallable(&ForecastServiceClient::ListForecasts, request);
        }
 
        template<typename ListForecastsRequestT = Model::ListForecastsRequest>
        void ListForecastsAsync(const ListForecastsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListForecastsRequestT& request = {}) const
        {
            return SubmitAsync(&ForecastServiceClient::ListForecasts, request, handler, context);
        }
 
        virtual Model::ListMonitorEvaluationsOutcome ListMonitorEvaluations(const Model::ListMonitorEvaluationsRequest& request) const;
 
        template<typename ListMonitorEvaluationsRequestT = Model::ListMonitorEvaluationsRequest>
        Model::ListMonitorEvaluationsOutcomeCallable ListMonitorEvaluationsCallable(const ListMonitorEvaluationsRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::ListMonitorEvaluations, request);
        }
 
        template<typename ListMonitorEvaluationsRequestT = Model::ListMonitorEvaluationsRequest>
        void ListMonitorEvaluationsAsync(const ListMonitorEvaluationsRequestT& request, const ListMonitorEvaluationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::ListMonitorEvaluations, request, handler, context);
        }
 
        virtual Model::ListMonitorsOutcome ListMonitors(const Model::ListMonitorsRequest& request = {}) const;
 
        template<typename ListMonitorsRequestT = Model::ListMonitorsRequest>
        Model::ListMonitorsOutcomeCallable ListMonitorsCallable(const ListMonitorsRequestT& request = {}) const
        {
            return SubmitCallable(&ForecastServiceClient::ListMonitors, request);
        }
 
        template<typename ListMonitorsRequestT = Model::ListMonitorsRequest>
        void ListMonitorsAsync(const ListMonitorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListMonitorsRequestT& request = {}) const
        {
            return SubmitAsync(&ForecastServiceClient::ListMonitors, request, handler, context);
        }
 
        virtual Model::ListPredictorBacktestExportJobsOutcome ListPredictorBacktestExportJobs(const Model::ListPredictorBacktestExportJobsRequest& request = {}) const;
 
        template<typename ListPredictorBacktestExportJobsRequestT = Model::ListPredictorBacktestExportJobsRequest>
        Model::ListPredictorBacktestExportJobsOutcomeCallable ListPredictorBacktestExportJobsCallable(const ListPredictorBacktestExportJobsRequestT& request = {}) const
        {
            return SubmitCallable(&ForecastServiceClient::ListPredictorBacktestExportJobs, request);
        }
 
        template<typename ListPredictorBacktestExportJobsRequestT = Model::ListPredictorBacktestExportJobsRequest>
        void ListPredictorBacktestExportJobsAsync(const ListPredictorBacktestExportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPredictorBacktestExportJobsRequestT& request = {}) const
        {
            return SubmitAsync(&ForecastServiceClient::ListPredictorBacktestExportJobs, request, handler, context);
        }
 
        virtual Model::ListPredictorsOutcome ListPredictors(const Model::ListPredictorsRequest& request = {}) const;
 
        template<typename ListPredictorsRequestT = Model::ListPredictorsRequest>
        Model::ListPredictorsOutcomeCallable ListPredictorsCallable(const ListPredictorsRequestT& request = {}) const
        {
            return SubmitCallable(&ForecastServiceClient::ListPredictors, request);
        }
 
        template<typename ListPredictorsRequestT = Model::ListPredictorsRequest>
        void ListPredictorsAsync(const ListPredictorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPredictorsRequestT& request = {}) const
        {
            return SubmitAsync(&ForecastServiceClient::ListPredictors, 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(&ForecastServiceClient::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(&ForecastServiceClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListWhatIfAnalysesOutcome ListWhatIfAnalyses(const Model::ListWhatIfAnalysesRequest& request = {}) const;
 
        template<typename ListWhatIfAnalysesRequestT = Model::ListWhatIfAnalysesRequest>
        Model::ListWhatIfAnalysesOutcomeCallable ListWhatIfAnalysesCallable(const ListWhatIfAnalysesRequestT& request = {}) const
        {
            return SubmitCallable(&ForecastServiceClient::ListWhatIfAnalyses, request);
        }
 
        template<typename ListWhatIfAnalysesRequestT = Model::ListWhatIfAnalysesRequest>
        void ListWhatIfAnalysesAsync(const ListWhatIfAnalysesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListWhatIfAnalysesRequestT& request = {}) const
        {
            return SubmitAsync(&ForecastServiceClient::ListWhatIfAnalyses, request, handler, context);
        }
 
        virtual Model::ListWhatIfForecastExportsOutcome ListWhatIfForecastExports(const Model::ListWhatIfForecastExportsRequest& request = {}) const;
 
        template<typename ListWhatIfForecastExportsRequestT = Model::ListWhatIfForecastExportsRequest>
        Model::ListWhatIfForecastExportsOutcomeCallable ListWhatIfForecastExportsCallable(const ListWhatIfForecastExportsRequestT& request = {}) const
        {
            return SubmitCallable(&ForecastServiceClient::ListWhatIfForecastExports, request);
        }
 
        template<typename ListWhatIfForecastExportsRequestT = Model::ListWhatIfForecastExportsRequest>
        void ListWhatIfForecastExportsAsync(const ListWhatIfForecastExportsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListWhatIfForecastExportsRequestT& request = {}) const
        {
            return SubmitAsync(&ForecastServiceClient::ListWhatIfForecastExports, request, handler, context);
        }
 
        virtual Model::ListWhatIfForecastsOutcome ListWhatIfForecasts(const Model::ListWhatIfForecastsRequest& request = {}) const;
 
        template<typename ListWhatIfForecastsRequestT = Model::ListWhatIfForecastsRequest>
        Model::ListWhatIfForecastsOutcomeCallable ListWhatIfForecastsCallable(const ListWhatIfForecastsRequestT& request = {}) const
        {
            return SubmitCallable(&ForecastServiceClient::ListWhatIfForecasts, request);
        }
 
        template<typename ListWhatIfForecastsRequestT = Model::ListWhatIfForecastsRequest>
        void ListWhatIfForecastsAsync(const ListWhatIfForecastsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListWhatIfForecastsRequestT& request = {}) const
        {
            return SubmitAsync(&ForecastServiceClient::ListWhatIfForecasts, request, handler, context);
        }
 
        virtual Model::ResumeResourceOutcome ResumeResource(const Model::ResumeResourceRequest& request) const;
 
        template<typename ResumeResourceRequestT = Model::ResumeResourceRequest>
        Model::ResumeResourceOutcomeCallable ResumeResourceCallable(const ResumeResourceRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::ResumeResource, request);
        }
 
        template<typename ResumeResourceRequestT = Model::ResumeResourceRequest>
        void ResumeResourceAsync(const ResumeResourceRequestT& request, const ResumeResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::ResumeResource, request, handler, context);
        }
 
        virtual Model::StopResourceOutcome StopResource(const Model::StopResourceRequest& request) const;
 
        template<typename StopResourceRequestT = Model::StopResourceRequest>
        Model::StopResourceOutcomeCallable StopResourceCallable(const StopResourceRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::StopResource, request);
        }
 
        template<typename StopResourceRequestT = Model::StopResourceRequest>
        void StopResourceAsync(const StopResourceRequestT& request, const StopResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::StopResource, 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(&ForecastServiceClient::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(&ForecastServiceClient::TagResource, request, handler, context);
        }
 
        virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::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(&ForecastServiceClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateDatasetGroupOutcome UpdateDatasetGroup(const Model::UpdateDatasetGroupRequest& request) const;
 
        template<typename UpdateDatasetGroupRequestT = Model::UpdateDatasetGroupRequest>
        Model::UpdateDatasetGroupOutcomeCallable UpdateDatasetGroupCallable(const UpdateDatasetGroupRequestT& request) const
        {
            return SubmitCallable(&ForecastServiceClient::UpdateDatasetGroup, request);
        }
 
        template<typename UpdateDatasetGroupRequestT = Model::UpdateDatasetGroupRequest>
        void UpdateDatasetGroupAsync(const UpdateDatasetGroupRequestT& request, const UpdateDatasetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ForecastServiceClient::UpdateDatasetGroup, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<ForecastServiceEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<ForecastServiceClient>;
      void init(const ForecastServiceClientConfiguration& clientConfiguration);
 
      ForecastServiceClientConfiguration m_clientConfiguration;
      std::shared_ptr<ForecastServiceEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace ForecastService
} // namespace Aws