BudgetsClient.h

 
#pragma once
#include <aws/budgets/Budgets_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/budgets/BudgetsServiceClientModel.h>
 
namespace Aws
{
namespace Budgets
{
  class AWS_BUDGETS_API BudgetsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<BudgetsEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<BudgetsClient>;
      void init(const BudgetsClientConfiguration& clientConfiguration);
 
      BudgetsClientConfiguration m_clientConfiguration;
      std::shared_ptr<BudgetsEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Budgets
} // namespace Aws