BudgetsClient.h

 
#pragma once
#include <aws/budgets/BudgetsPaginationBase.h>
#include <aws/budgets/BudgetsServiceClientModel.h>
#include <aws/budgets/BudgetsWaiter.h>
#include <aws/budgets/Budgets_EXPORTS.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
 
namespace Aws {
namespace Budgets {
class AWS_BUDGETS_API BudgetsClient : public Aws::Client::AWSJsonClient,
                                      public Aws::Client::ClientWithAsyncTemplateMethods<BudgetsClient>,
                                      public BudgetsPaginationBase<BudgetsClient>,
                                      public BudgetsWaiter<BudgetsClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef BudgetsClientConfiguration ClientConfigurationType;
  typedef BudgetsEndpointProvider EndpointProviderType;
 
  BudgetsClient(const Aws::Budgets::BudgetsClientConfiguration& clientConfiguration = Aws::Budgets::BudgetsClientConfiguration(),
                std::shared_ptr<BudgetsEndpointProviderBase> endpointProvider = nullptr);
 
  BudgetsClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<BudgetsEndpointProviderBase> endpointProvider = nullptr,
                const Aws::Budgets::BudgetsClientConfiguration& clientConfiguration = Aws::Budgets::BudgetsClientConfiguration());
 
  BudgetsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                std::shared_ptr<BudgetsEndpointProviderBase> endpointProvider = nullptr,
                const Aws::Budgets::BudgetsClientConfiguration& clientConfiguration = Aws::Budgets::BudgetsClientConfiguration());
 
  /* Legacy constructors due deprecation */
  BudgetsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  BudgetsClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  BudgetsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~BudgetsClient();
 
  virtual Model::CreateBudgetOutcome CreateBudget(const Model::CreateBudgetRequest& request) const;
 
  template <typename CreateBudgetRequestT = Model::CreateBudgetRequest>
  Model::CreateBudgetOutcomeCallable CreateBudgetCallable(const CreateBudgetRequestT& request) const {
    return SubmitCallable(&BudgetsClient::CreateBudget, request);
  }
 
  template <typename CreateBudgetRequestT = Model::CreateBudgetRequest>
  void CreateBudgetAsync(const CreateBudgetRequestT& request, const CreateBudgetResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BudgetsClient::CreateBudget, request, handler, context);
  }
 
  virtual Model::CreateBudgetActionOutcome CreateBudgetAction(const Model::CreateBudgetActionRequest& request) const;
 
  template <typename CreateBudgetActionRequestT = Model::CreateBudgetActionRequest>
  Model::CreateBudgetActionOutcomeCallable CreateBudgetActionCallable(const CreateBudgetActionRequestT& request) const {
    return SubmitCallable(&BudgetsClient::CreateBudgetAction, request);
  }
 
  template <typename CreateBudgetActionRequestT = Model::CreateBudgetActionRequest>
  void CreateBudgetActionAsync(const CreateBudgetActionRequestT& request, const CreateBudgetActionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BudgetsClient::CreateBudgetAction, request, handler, context);
  }
 
  virtual Model::CreateNotificationOutcome CreateNotification(const Model::CreateNotificationRequest& request) const;
 
  template <typename CreateNotificationRequestT = Model::CreateNotificationRequest>
  Model::CreateNotificationOutcomeCallable CreateNotificationCallable(const CreateNotificationRequestT& request) const {
    return SubmitCallable(&BudgetsClient::CreateNotification, request);
  }
 
  template <typename CreateNotificationRequestT = Model::CreateNotificationRequest>
  void CreateNotificationAsync(const CreateNotificationRequestT& request, const CreateNotificationResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BudgetsClient::CreateNotification, request, handler, context);
  }
 
  virtual Model::CreateSubscriberOutcome CreateSubscriber(const Model::CreateSubscriberRequest& request) const;
 
  template <typename CreateSubscriberRequestT = Model::CreateSubscriberRequest>
  Model::CreateSubscriberOutcomeCallable CreateSubscriberCallable(const CreateSubscriberRequestT& request) const {
    return SubmitCallable(&BudgetsClient::CreateSubscriber, request);
  }
 
  template <typename CreateSubscriberRequestT = Model::CreateSubscriberRequest>
  void CreateSubscriberAsync(const CreateSubscriberRequestT& request, const CreateSubscriberResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BudgetsClient::CreateSubscriber, request, handler, context);
  }
 
  virtual Model::DeleteBudgetOutcome DeleteBudget(const Model::DeleteBudgetRequest& request) const;
 
  template <typename DeleteBudgetRequestT = Model::DeleteBudgetRequest>
  Model::DeleteBudgetOutcomeCallable DeleteBudgetCallable(const DeleteBudgetRequestT& request) const {
    return SubmitCallable(&BudgetsClient::DeleteBudget, request);
  }
 
  template <typename DeleteBudgetRequestT = Model::DeleteBudgetRequest>
  void DeleteBudgetAsync(const DeleteBudgetRequestT& request, const DeleteBudgetResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BudgetsClient::DeleteBudget, request, handler, context);
  }
 
  virtual Model::DeleteBudgetActionOutcome DeleteBudgetAction(const Model::DeleteBudgetActionRequest& request) const;
 
  template <typename DeleteBudgetActionRequestT = Model::DeleteBudgetActionRequest>
  Model::DeleteBudgetActionOutcomeCallable DeleteBudgetActionCallable(const DeleteBudgetActionRequestT& request) const {
    return SubmitCallable(&BudgetsClient::DeleteBudgetAction, request);
  }
 
  template <typename DeleteBudgetActionRequestT = Model::DeleteBudgetActionRequest>
  void DeleteBudgetActionAsync(const DeleteBudgetActionRequestT& request, const DeleteBudgetActionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BudgetsClient::DeleteBudgetAction, request, handler, context);
  }
 
  virtual Model::DeleteNotificationOutcome DeleteNotification(const Model::DeleteNotificationRequest& request) const;
 
  template <typename DeleteNotificationRequestT = Model::DeleteNotificationRequest>
  Model::DeleteNotificationOutcomeCallable DeleteNotificationCallable(const DeleteNotificationRequestT& request) const {
    return SubmitCallable(&BudgetsClient::DeleteNotification, request);
  }
 
  template <typename DeleteNotificationRequestT = Model::DeleteNotificationRequest>
  void DeleteNotificationAsync(const DeleteNotificationRequestT& request, const DeleteNotificationResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BudgetsClient::DeleteNotification, request, handler, context);
  }
 
  virtual Model::DeleteSubscriberOutcome DeleteSubscriber(const Model::DeleteSubscriberRequest& request) const;
 
  template <typename DeleteSubscriberRequestT = Model::DeleteSubscriberRequest>
  Model::DeleteSubscriberOutcomeCallable DeleteSubscriberCallable(const DeleteSubscriberRequestT& request) const {
    return SubmitCallable(&BudgetsClient::DeleteSubscriber, request);
  }
 
  template <typename DeleteSubscriberRequestT = Model::DeleteSubscriberRequest>
  void DeleteSubscriberAsync(const DeleteSubscriberRequestT& request, const DeleteSubscriberResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BudgetsClient::DeleteSubscriber, request, handler, context);
  }
 
  virtual Model::DescribeBudgetOutcome DescribeBudget(const Model::DescribeBudgetRequest& request) const;
 
  template <typename DescribeBudgetRequestT = Model::DescribeBudgetRequest>
  Model::DescribeBudgetOutcomeCallable DescribeBudgetCallable(const DescribeBudgetRequestT& request) const {
    return SubmitCallable(&BudgetsClient::DescribeBudget, request);
  }
 
  template <typename DescribeBudgetRequestT = Model::DescribeBudgetRequest>
  void DescribeBudgetAsync(const DescribeBudgetRequestT& request, const DescribeBudgetResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BudgetsClient::DescribeBudget, request, handler, context);
  }
 
  virtual Model::DescribeBudgetActionOutcome DescribeBudgetAction(const Model::DescribeBudgetActionRequest& request) const;
 
  template <typename DescribeBudgetActionRequestT = Model::DescribeBudgetActionRequest>
  Model::DescribeBudgetActionOutcomeCallable DescribeBudgetActionCallable(const DescribeBudgetActionRequestT& request) const {
    return SubmitCallable(&BudgetsClient::DescribeBudgetAction, request);
  }
 
  template <typename DescribeBudgetActionRequestT = Model::DescribeBudgetActionRequest>
  void DescribeBudgetActionAsync(const DescribeBudgetActionRequestT& request, const DescribeBudgetActionResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BudgetsClient::DescribeBudgetAction, request, handler, context);
  }
 
  virtual Model::DescribeBudgetActionHistoriesOutcome DescribeBudgetActionHistories(
      const Model::DescribeBudgetActionHistoriesRequest& request) const;
 
  template <typename DescribeBudgetActionHistoriesRequestT = Model::DescribeBudgetActionHistoriesRequest>
  Model::DescribeBudgetActionHistoriesOutcomeCallable DescribeBudgetActionHistoriesCallable(
      const DescribeBudgetActionHistoriesRequestT& request) const {
    return SubmitCallable(&BudgetsClient::DescribeBudgetActionHistories, request);
  }
 
  template <typename DescribeBudgetActionHistoriesRequestT = Model::DescribeBudgetActionHistoriesRequest>
  void DescribeBudgetActionHistoriesAsync(const DescribeBudgetActionHistoriesRequestT& request,
                                          const DescribeBudgetActionHistoriesResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BudgetsClient::DescribeBudgetActionHistories, request, handler, context);
  }
 
  virtual Model::DescribeBudgetActionsForAccountOutcome DescribeBudgetActionsForAccount(
      const Model::DescribeBudgetActionsForAccountRequest& request) const;
 
  template <typename DescribeBudgetActionsForAccountRequestT = Model::DescribeBudgetActionsForAccountRequest>
  Model::DescribeBudgetActionsForAccountOutcomeCallable DescribeBudgetActionsForAccountCallable(
      const DescribeBudgetActionsForAccountRequestT& request) const {
    return SubmitCallable(&BudgetsClient::DescribeBudgetActionsForAccount, request);
  }
 
  template <typename DescribeBudgetActionsForAccountRequestT = Model::DescribeBudgetActionsForAccountRequest>
  void DescribeBudgetActionsForAccountAsync(const DescribeBudgetActionsForAccountRequestT& request,
                                            const DescribeBudgetActionsForAccountResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BudgetsClient::DescribeBudgetActionsForAccount, request, handler, context);
  }
 
  virtual Model::DescribeBudgetActionsForBudgetOutcome DescribeBudgetActionsForBudget(
      const Model::DescribeBudgetActionsForBudgetRequest& request) const;
 
  template <typename DescribeBudgetActionsForBudgetRequestT = Model::DescribeBudgetActionsForBudgetRequest>
  Model::DescribeBudgetActionsForBudgetOutcomeCallable DescribeBudgetActionsForBudgetCallable(
      const DescribeBudgetActionsForBudgetRequestT& request) const {
    return SubmitCallable(&BudgetsClient::DescribeBudgetActionsForBudget, request);
  }
 
  template <typename DescribeBudgetActionsForBudgetRequestT = Model::DescribeBudgetActionsForBudgetRequest>
  void DescribeBudgetActionsForBudgetAsync(const DescribeBudgetActionsForBudgetRequestT& request,
                                           const DescribeBudgetActionsForBudgetResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BudgetsClient::DescribeBudgetActionsForBudget, request, handler, context);
  }
 
  virtual Model::DescribeBudgetNotificationsForAccountOutcome DescribeBudgetNotificationsForAccount(
      const Model::DescribeBudgetNotificationsForAccountRequest& request) const;
 
  template <typename DescribeBudgetNotificationsForAccountRequestT = Model::DescribeBudgetNotificationsForAccountRequest>
  Model::DescribeBudgetNotificationsForAccountOutcomeCallable DescribeBudgetNotificationsForAccountCallable(
      const DescribeBudgetNotificationsForAccountRequestT& request) const {
    return SubmitCallable(&BudgetsClient::DescribeBudgetNotificationsForAccount, request);
  }
 
  template <typename DescribeBudgetNotificationsForAccountRequestT = Model::DescribeBudgetNotificationsForAccountRequest>
  void DescribeBudgetNotificationsForAccountAsync(const DescribeBudgetNotificationsForAccountRequestT& request,
                                                  const DescribeBudgetNotificationsForAccountResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BudgetsClient::DescribeBudgetNotificationsForAccount, request, handler, context);
  }
 
  virtual Model::DescribeBudgetPerformanceHistoryOutcome DescribeBudgetPerformanceHistory(
      const Model::DescribeBudgetPerformanceHistoryRequest& request) const;
 
  template <typename DescribeBudgetPerformanceHistoryRequestT = Model::DescribeBudgetPerformanceHistoryRequest>
  Model::DescribeBudgetPerformanceHistoryOutcomeCallable DescribeBudgetPerformanceHistoryCallable(
      const DescribeBudgetPerformanceHistoryRequestT& request) const {
    return SubmitCallable(&BudgetsClient::DescribeBudgetPerformanceHistory, request);
  }
 
  template <typename DescribeBudgetPerformanceHistoryRequestT = Model::DescribeBudgetPerformanceHistoryRequest>
  void DescribeBudgetPerformanceHistoryAsync(const DescribeBudgetPerformanceHistoryRequestT& request,
                                             const DescribeBudgetPerformanceHistoryResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BudgetsClient::DescribeBudgetPerformanceHistory, request, handler, context);
  }
 
  virtual Model::DescribeBudgetsOutcome DescribeBudgets(const Model::DescribeBudgetsRequest& request) const;
 
  template <typename DescribeBudgetsRequestT = Model::DescribeBudgetsRequest>
  Model::DescribeBudgetsOutcomeCallable DescribeBudgetsCallable(const DescribeBudgetsRequestT& request) const {
    return SubmitCallable(&BudgetsClient::DescribeBudgets, request);
  }
 
  template <typename DescribeBudgetsRequestT = Model::DescribeBudgetsRequest>
  void DescribeBudgetsAsync(const DescribeBudgetsRequestT& request, const DescribeBudgetsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BudgetsClient::DescribeBudgets, request, handler, context);
  }
 
  virtual Model::DescribeNotificationsForBudgetOutcome DescribeNotificationsForBudget(
      const Model::DescribeNotificationsForBudgetRequest& request) const;
 
  template <typename DescribeNotificationsForBudgetRequestT = Model::DescribeNotificationsForBudgetRequest>
  Model::DescribeNotificationsForBudgetOutcomeCallable DescribeNotificationsForBudgetCallable(
      const DescribeNotificationsForBudgetRequestT& request) const {
    return SubmitCallable(&BudgetsClient::DescribeNotificationsForBudget, request);
  }
 
  template <typename DescribeNotificationsForBudgetRequestT = Model::DescribeNotificationsForBudgetRequest>
  void DescribeNotificationsForBudgetAsync(const DescribeNotificationsForBudgetRequestT& request,
                                           const DescribeNotificationsForBudgetResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BudgetsClient::DescribeNotificationsForBudget, request, handler, context);
  }
 
  virtual Model::DescribeSubscribersForNotificationOutcome DescribeSubscribersForNotification(
      const Model::DescribeSubscribersForNotificationRequest& request) const;
 
  template <typename DescribeSubscribersForNotificationRequestT = Model::DescribeSubscribersForNotificationRequest>
  Model::DescribeSubscribersForNotificationOutcomeCallable DescribeSubscribersForNotificationCallable(
      const DescribeSubscribersForNotificationRequestT& request) const {
    return SubmitCallable(&BudgetsClient::DescribeSubscribersForNotification, request);
  }
 
  template <typename DescribeSubscribersForNotificationRequestT = Model::DescribeSubscribersForNotificationRequest>
  void DescribeSubscribersForNotificationAsync(const DescribeSubscribersForNotificationRequestT& request,
                                               const DescribeSubscribersForNotificationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BudgetsClient::DescribeSubscribersForNotification, request, handler, context);
  }
 
  virtual Model::ExecuteBudgetActionOutcome ExecuteBudgetAction(const Model::ExecuteBudgetActionRequest& request) const;
 
  template <typename ExecuteBudgetActionRequestT = Model::ExecuteBudgetActionRequest>
  Model::ExecuteBudgetActionOutcomeCallable ExecuteBudgetActionCallable(const ExecuteBudgetActionRequestT& request) const {
    return SubmitCallable(&BudgetsClient::ExecuteBudgetAction, request);
  }
 
  template <typename ExecuteBudgetActionRequestT = Model::ExecuteBudgetActionRequest>
  void ExecuteBudgetActionAsync(const ExecuteBudgetActionRequestT& request, const ExecuteBudgetActionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BudgetsClient::ExecuteBudgetAction, 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(&BudgetsClient::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(&BudgetsClient::ListTagsForResource, 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(&BudgetsClient::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(&BudgetsClient::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(&BudgetsClient::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(&BudgetsClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateBudgetOutcome UpdateBudget(const Model::UpdateBudgetRequest& request) const;
 
  template <typename UpdateBudgetRequestT = Model::UpdateBudgetRequest>
  Model::UpdateBudgetOutcomeCallable UpdateBudgetCallable(const UpdateBudgetRequestT& request) const {
    return SubmitCallable(&BudgetsClient::UpdateBudget, request);
  }
 
  template <typename UpdateBudgetRequestT = Model::UpdateBudgetRequest>
  void UpdateBudgetAsync(const UpdateBudgetRequestT& request, const UpdateBudgetResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BudgetsClient::UpdateBudget, request, handler, context);
  }
 
  virtual Model::UpdateBudgetActionOutcome UpdateBudgetAction(const Model::UpdateBudgetActionRequest& request) const;
 
  template <typename UpdateBudgetActionRequestT = Model::UpdateBudgetActionRequest>
  Model::UpdateBudgetActionOutcomeCallable UpdateBudgetActionCallable(const UpdateBudgetActionRequestT& request) const {
    return SubmitCallable(&BudgetsClient::UpdateBudgetAction, request);
  }
 
  template <typename UpdateBudgetActionRequestT = Model::UpdateBudgetActionRequest>
  void UpdateBudgetActionAsync(const UpdateBudgetActionRequestT& request, const UpdateBudgetActionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BudgetsClient::UpdateBudgetAction, request, handler, context);
  }
 
  virtual Model::UpdateNotificationOutcome UpdateNotification(const Model::UpdateNotificationRequest& request) const;
 
  template <typename UpdateNotificationRequestT = Model::UpdateNotificationRequest>
  Model::UpdateNotificationOutcomeCallable UpdateNotificationCallable(const UpdateNotificationRequestT& request) const {
    return SubmitCallable(&BudgetsClient::UpdateNotification, request);
  }
 
  template <typename UpdateNotificationRequestT = Model::UpdateNotificationRequest>
  void UpdateNotificationAsync(const UpdateNotificationRequestT& request, const UpdateNotificationResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BudgetsClient::UpdateNotification, request, handler, context);
  }
 
  virtual Model::UpdateSubscriberOutcome UpdateSubscriber(const Model::UpdateSubscriberRequest& request) const;
 
  template <typename UpdateSubscriberRequestT = Model::UpdateSubscriberRequest>
  Model::UpdateSubscriberOutcomeCallable UpdateSubscriberCallable(const UpdateSubscriberRequestT& request) const {
    return SubmitCallable(&BudgetsClient::UpdateSubscriber, request);
  }
 
  template <typename UpdateSubscriberRequestT = Model::UpdateSubscriberRequest>
  void UpdateSubscriberAsync(const UpdateSubscriberRequestT& request, const UpdateSubscriberResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BudgetsClient::UpdateSubscriber, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<BudgetsEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<BudgetsClient>;
  void init(const BudgetsClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, BudgetsError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  BudgetsClientConfiguration m_clientConfiguration;
  std::shared_ptr<BudgetsEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Budgets
}  // namespace Aws