NotificationsClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/notifications/NotificationsServiceClientModel.h>
#include <aws/notifications/Notifications_EXPORTS.h>
 
namespace Aws {
namespace Notifications {
class AWS_NOTIFICATIONS_API NotificationsClient : public Aws::Client::AWSJsonClient,
                                                  public Aws::Client::ClientWithAsyncTemplateMethods<NotificationsClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef NotificationsClientConfiguration ClientConfigurationType;
  typedef NotificationsEndpointProvider EndpointProviderType;
 
  NotificationsClient(const Aws::Notifications::NotificationsClientConfiguration& clientConfiguration =
                          Aws::Notifications::NotificationsClientConfiguration(),
                      std::shared_ptr<NotificationsEndpointProviderBase> endpointProvider = nullptr);
 
  NotificationsClient(const Aws::Auth::AWSCredentials& credentials,
                      std::shared_ptr<NotificationsEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::Notifications::NotificationsClientConfiguration& clientConfiguration =
                          Aws::Notifications::NotificationsClientConfiguration());
 
  NotificationsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      std::shared_ptr<NotificationsEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::Notifications::NotificationsClientConfiguration& clientConfiguration =
                          Aws::Notifications::NotificationsClientConfiguration());
 
  /* Legacy constructors due deprecation */
  NotificationsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  NotificationsClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  NotificationsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~NotificationsClient();
 
  virtual Model::AssociateChannelOutcome AssociateChannel(const Model::AssociateChannelRequest& request) const;
 
  template <typename AssociateChannelRequestT = Model::AssociateChannelRequest>
  Model::AssociateChannelOutcomeCallable AssociateChannelCallable(const AssociateChannelRequestT& request) const {
    return SubmitCallable(&NotificationsClient::AssociateChannel, request);
  }
 
  template <typename AssociateChannelRequestT = Model::AssociateChannelRequest>
  void AssociateChannelAsync(const AssociateChannelRequestT& request, const AssociateChannelResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::AssociateChannel, request, handler, context);
  }
 
  virtual Model::AssociateManagedNotificationAccountContactOutcome AssociateManagedNotificationAccountContact(
      const Model::AssociateManagedNotificationAccountContactRequest& request) const;
 
  template <typename AssociateManagedNotificationAccountContactRequestT = Model::AssociateManagedNotificationAccountContactRequest>
  Model::AssociateManagedNotificationAccountContactOutcomeCallable AssociateManagedNotificationAccountContactCallable(
      const AssociateManagedNotificationAccountContactRequestT& request) const {
    return SubmitCallable(&NotificationsClient::AssociateManagedNotificationAccountContact, request);
  }
 
  template <typename AssociateManagedNotificationAccountContactRequestT = Model::AssociateManagedNotificationAccountContactRequest>
  void AssociateManagedNotificationAccountContactAsync(
      const AssociateManagedNotificationAccountContactRequestT& request,
      const AssociateManagedNotificationAccountContactResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::AssociateManagedNotificationAccountContact, request, handler, context);
  }
 
  virtual Model::AssociateManagedNotificationAdditionalChannelOutcome AssociateManagedNotificationAdditionalChannel(
      const Model::AssociateManagedNotificationAdditionalChannelRequest& request) const;
 
  template <typename AssociateManagedNotificationAdditionalChannelRequestT = Model::AssociateManagedNotificationAdditionalChannelRequest>
  Model::AssociateManagedNotificationAdditionalChannelOutcomeCallable AssociateManagedNotificationAdditionalChannelCallable(
      const AssociateManagedNotificationAdditionalChannelRequestT& request) const {
    return SubmitCallable(&NotificationsClient::AssociateManagedNotificationAdditionalChannel, request);
  }
 
  template <typename AssociateManagedNotificationAdditionalChannelRequestT = Model::AssociateManagedNotificationAdditionalChannelRequest>
  void AssociateManagedNotificationAdditionalChannelAsync(
      const AssociateManagedNotificationAdditionalChannelRequestT& request,
      const AssociateManagedNotificationAdditionalChannelResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::AssociateManagedNotificationAdditionalChannel, request, handler, context);
  }
 
  virtual Model::AssociateOrganizationalUnitOutcome AssociateOrganizationalUnit(
      const Model::AssociateOrganizationalUnitRequest& request) const;
 
  template <typename AssociateOrganizationalUnitRequestT = Model::AssociateOrganizationalUnitRequest>
  Model::AssociateOrganizationalUnitOutcomeCallable AssociateOrganizationalUnitCallable(
      const AssociateOrganizationalUnitRequestT& request) const {
    return SubmitCallable(&NotificationsClient::AssociateOrganizationalUnit, request);
  }
 
  template <typename AssociateOrganizationalUnitRequestT = Model::AssociateOrganizationalUnitRequest>
  void AssociateOrganizationalUnitAsync(const AssociateOrganizationalUnitRequestT& request,
                                        const AssociateOrganizationalUnitResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::AssociateOrganizationalUnit, request, handler, context);
  }
 
  virtual Model::CreateEventRuleOutcome CreateEventRule(const Model::CreateEventRuleRequest& request) const;
 
  template <typename CreateEventRuleRequestT = Model::CreateEventRuleRequest>
  Model::CreateEventRuleOutcomeCallable CreateEventRuleCallable(const CreateEventRuleRequestT& request) const {
    return SubmitCallable(&NotificationsClient::CreateEventRule, request);
  }
 
  template <typename CreateEventRuleRequestT = Model::CreateEventRuleRequest>
  void CreateEventRuleAsync(const CreateEventRuleRequestT& request, const CreateEventRuleResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::CreateEventRule, request, handler, context);
  }
 
  virtual Model::CreateNotificationConfigurationOutcome CreateNotificationConfiguration(
      const Model::CreateNotificationConfigurationRequest& request) const;
 
  template <typename CreateNotificationConfigurationRequestT = Model::CreateNotificationConfigurationRequest>
  Model::CreateNotificationConfigurationOutcomeCallable CreateNotificationConfigurationCallable(
      const CreateNotificationConfigurationRequestT& request) const {
    return SubmitCallable(&NotificationsClient::CreateNotificationConfiguration, request);
  }
 
  template <typename CreateNotificationConfigurationRequestT = Model::CreateNotificationConfigurationRequest>
  void CreateNotificationConfigurationAsync(const CreateNotificationConfigurationRequestT& request,
                                            const CreateNotificationConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::CreateNotificationConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteEventRuleOutcome DeleteEventRule(const Model::DeleteEventRuleRequest& request) const;
 
  template <typename DeleteEventRuleRequestT = Model::DeleteEventRuleRequest>
  Model::DeleteEventRuleOutcomeCallable DeleteEventRuleCallable(const DeleteEventRuleRequestT& request) const {
    return SubmitCallable(&NotificationsClient::DeleteEventRule, request);
  }
 
  template <typename DeleteEventRuleRequestT = Model::DeleteEventRuleRequest>
  void DeleteEventRuleAsync(const DeleteEventRuleRequestT& request, const DeleteEventRuleResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::DeleteEventRule, request, handler, context);
  }
 
  virtual Model::DeleteNotificationConfigurationOutcome DeleteNotificationConfiguration(
      const Model::DeleteNotificationConfigurationRequest& request) const;
 
  template <typename DeleteNotificationConfigurationRequestT = Model::DeleteNotificationConfigurationRequest>
  Model::DeleteNotificationConfigurationOutcomeCallable DeleteNotificationConfigurationCallable(
      const DeleteNotificationConfigurationRequestT& request) const {
    return SubmitCallable(&NotificationsClient::DeleteNotificationConfiguration, request);
  }
 
  template <typename DeleteNotificationConfigurationRequestT = Model::DeleteNotificationConfigurationRequest>
  void DeleteNotificationConfigurationAsync(const DeleteNotificationConfigurationRequestT& request,
                                            const DeleteNotificationConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::DeleteNotificationConfiguration, request, handler, context);
  }
 
  virtual Model::DeregisterNotificationHubOutcome DeregisterNotificationHub(const Model::DeregisterNotificationHubRequest& request) const;
 
  template <typename DeregisterNotificationHubRequestT = Model::DeregisterNotificationHubRequest>
  Model::DeregisterNotificationHubOutcomeCallable DeregisterNotificationHubCallable(
      const DeregisterNotificationHubRequestT& request) const {
    return SubmitCallable(&NotificationsClient::DeregisterNotificationHub, request);
  }
 
  template <typename DeregisterNotificationHubRequestT = Model::DeregisterNotificationHubRequest>
  void DeregisterNotificationHubAsync(const DeregisterNotificationHubRequestT& request,
                                      const DeregisterNotificationHubResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::DeregisterNotificationHub, request, handler, context);
  }
 
  virtual Model::DisableNotificationsAccessForOrganizationOutcome DisableNotificationsAccessForOrganization(
      const Model::DisableNotificationsAccessForOrganizationRequest& request = {}) const;
 
  template <typename DisableNotificationsAccessForOrganizationRequestT = Model::DisableNotificationsAccessForOrganizationRequest>
  Model::DisableNotificationsAccessForOrganizationOutcomeCallable DisableNotificationsAccessForOrganizationCallable(
      const DisableNotificationsAccessForOrganizationRequestT& request = {}) const {
    return SubmitCallable(&NotificationsClient::DisableNotificationsAccessForOrganization, request);
  }
 
  template <typename DisableNotificationsAccessForOrganizationRequestT = Model::DisableNotificationsAccessForOrganizationRequest>
  void DisableNotificationsAccessForOrganizationAsync(const DisableNotificationsAccessForOrganizationResponseReceivedHandler& handler,
                                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                      const DisableNotificationsAccessForOrganizationRequestT& request = {}) const {
    return SubmitAsync(&NotificationsClient::DisableNotificationsAccessForOrganization, request, handler, context);
  }
 
  virtual Model::DisassociateChannelOutcome DisassociateChannel(const Model::DisassociateChannelRequest& request) const;
 
  template <typename DisassociateChannelRequestT = Model::DisassociateChannelRequest>
  Model::DisassociateChannelOutcomeCallable DisassociateChannelCallable(const DisassociateChannelRequestT& request) const {
    return SubmitCallable(&NotificationsClient::DisassociateChannel, request);
  }
 
  template <typename DisassociateChannelRequestT = Model::DisassociateChannelRequest>
  void DisassociateChannelAsync(const DisassociateChannelRequestT& request, const DisassociateChannelResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::DisassociateChannel, request, handler, context);
  }
 
  virtual Model::DisassociateManagedNotificationAccountContactOutcome DisassociateManagedNotificationAccountContact(
      const Model::DisassociateManagedNotificationAccountContactRequest& request) const;
 
  template <typename DisassociateManagedNotificationAccountContactRequestT = Model::DisassociateManagedNotificationAccountContactRequest>
  Model::DisassociateManagedNotificationAccountContactOutcomeCallable DisassociateManagedNotificationAccountContactCallable(
      const DisassociateManagedNotificationAccountContactRequestT& request) const {
    return SubmitCallable(&NotificationsClient::DisassociateManagedNotificationAccountContact, request);
  }
 
  template <typename DisassociateManagedNotificationAccountContactRequestT = Model::DisassociateManagedNotificationAccountContactRequest>
  void DisassociateManagedNotificationAccountContactAsync(
      const DisassociateManagedNotificationAccountContactRequestT& request,
      const DisassociateManagedNotificationAccountContactResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::DisassociateManagedNotificationAccountContact, request, handler, context);
  }
 
  virtual Model::DisassociateManagedNotificationAdditionalChannelOutcome DisassociateManagedNotificationAdditionalChannel(
      const Model::DisassociateManagedNotificationAdditionalChannelRequest& request) const;
 
  template <
      typename DisassociateManagedNotificationAdditionalChannelRequestT = Model::DisassociateManagedNotificationAdditionalChannelRequest>
  Model::DisassociateManagedNotificationAdditionalChannelOutcomeCallable DisassociateManagedNotificationAdditionalChannelCallable(
      const DisassociateManagedNotificationAdditionalChannelRequestT& request) const {
    return SubmitCallable(&NotificationsClient::DisassociateManagedNotificationAdditionalChannel, request);
  }
 
  template <
      typename DisassociateManagedNotificationAdditionalChannelRequestT = Model::DisassociateManagedNotificationAdditionalChannelRequest>
  void DisassociateManagedNotificationAdditionalChannelAsync(
      const DisassociateManagedNotificationAdditionalChannelRequestT& request,
      const DisassociateManagedNotificationAdditionalChannelResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::DisassociateManagedNotificationAdditionalChannel, request, handler, context);
  }
 
  virtual Model::DisassociateOrganizationalUnitOutcome DisassociateOrganizationalUnit(
      const Model::DisassociateOrganizationalUnitRequest& request) const;
 
  template <typename DisassociateOrganizationalUnitRequestT = Model::DisassociateOrganizationalUnitRequest>
  Model::DisassociateOrganizationalUnitOutcomeCallable DisassociateOrganizationalUnitCallable(
      const DisassociateOrganizationalUnitRequestT& request) const {
    return SubmitCallable(&NotificationsClient::DisassociateOrganizationalUnit, request);
  }
 
  template <typename DisassociateOrganizationalUnitRequestT = Model::DisassociateOrganizationalUnitRequest>
  void DisassociateOrganizationalUnitAsync(const DisassociateOrganizationalUnitRequestT& request,
                                           const DisassociateOrganizationalUnitResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::DisassociateOrganizationalUnit, request, handler, context);
  }
 
  virtual Model::EnableNotificationsAccessForOrganizationOutcome EnableNotificationsAccessForOrganization(
      const Model::EnableNotificationsAccessForOrganizationRequest& request = {}) const;
 
  template <typename EnableNotificationsAccessForOrganizationRequestT = Model::EnableNotificationsAccessForOrganizationRequest>
  Model::EnableNotificationsAccessForOrganizationOutcomeCallable EnableNotificationsAccessForOrganizationCallable(
      const EnableNotificationsAccessForOrganizationRequestT& request = {}) const {
    return SubmitCallable(&NotificationsClient::EnableNotificationsAccessForOrganization, request);
  }
 
  template <typename EnableNotificationsAccessForOrganizationRequestT = Model::EnableNotificationsAccessForOrganizationRequest>
  void EnableNotificationsAccessForOrganizationAsync(const EnableNotificationsAccessForOrganizationResponseReceivedHandler& handler,
                                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                     const EnableNotificationsAccessForOrganizationRequestT& request = {}) const {
    return SubmitAsync(&NotificationsClient::EnableNotificationsAccessForOrganization, request, handler, context);
  }
 
  virtual Model::GetEventRuleOutcome GetEventRule(const Model::GetEventRuleRequest& request) const;
 
  template <typename GetEventRuleRequestT = Model::GetEventRuleRequest>
  Model::GetEventRuleOutcomeCallable GetEventRuleCallable(const GetEventRuleRequestT& request) const {
    return SubmitCallable(&NotificationsClient::GetEventRule, request);
  }
 
  template <typename GetEventRuleRequestT = Model::GetEventRuleRequest>
  void GetEventRuleAsync(const GetEventRuleRequestT& request, const GetEventRuleResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::GetEventRule, request, handler, context);
  }
 
  virtual Model::GetManagedNotificationChildEventOutcome GetManagedNotificationChildEvent(
      const Model::GetManagedNotificationChildEventRequest& request) const;
 
  template <typename GetManagedNotificationChildEventRequestT = Model::GetManagedNotificationChildEventRequest>
  Model::GetManagedNotificationChildEventOutcomeCallable GetManagedNotificationChildEventCallable(
      const GetManagedNotificationChildEventRequestT& request) const {
    return SubmitCallable(&NotificationsClient::GetManagedNotificationChildEvent, request);
  }
 
  template <typename GetManagedNotificationChildEventRequestT = Model::GetManagedNotificationChildEventRequest>
  void GetManagedNotificationChildEventAsync(const GetManagedNotificationChildEventRequestT& request,
                                             const GetManagedNotificationChildEventResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::GetManagedNotificationChildEvent, request, handler, context);
  }
 
  virtual Model::GetManagedNotificationConfigurationOutcome GetManagedNotificationConfiguration(
      const Model::GetManagedNotificationConfigurationRequest& request) const;
 
  template <typename GetManagedNotificationConfigurationRequestT = Model::GetManagedNotificationConfigurationRequest>
  Model::GetManagedNotificationConfigurationOutcomeCallable GetManagedNotificationConfigurationCallable(
      const GetManagedNotificationConfigurationRequestT& request) const {
    return SubmitCallable(&NotificationsClient::GetManagedNotificationConfiguration, request);
  }
 
  template <typename GetManagedNotificationConfigurationRequestT = Model::GetManagedNotificationConfigurationRequest>
  void GetManagedNotificationConfigurationAsync(const GetManagedNotificationConfigurationRequestT& request,
                                                const GetManagedNotificationConfigurationResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::GetManagedNotificationConfiguration, request, handler, context);
  }
 
  virtual Model::GetManagedNotificationEventOutcome GetManagedNotificationEvent(
      const Model::GetManagedNotificationEventRequest& request) const;
 
  template <typename GetManagedNotificationEventRequestT = Model::GetManagedNotificationEventRequest>
  Model::GetManagedNotificationEventOutcomeCallable GetManagedNotificationEventCallable(
      const GetManagedNotificationEventRequestT& request) const {
    return SubmitCallable(&NotificationsClient::GetManagedNotificationEvent, request);
  }
 
  template <typename GetManagedNotificationEventRequestT = Model::GetManagedNotificationEventRequest>
  void GetManagedNotificationEventAsync(const GetManagedNotificationEventRequestT& request,
                                        const GetManagedNotificationEventResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::GetManagedNotificationEvent, request, handler, context);
  }
 
  virtual Model::GetNotificationConfigurationOutcome GetNotificationConfiguration(
      const Model::GetNotificationConfigurationRequest& request) const;
 
  template <typename GetNotificationConfigurationRequestT = Model::GetNotificationConfigurationRequest>
  Model::GetNotificationConfigurationOutcomeCallable GetNotificationConfigurationCallable(
      const GetNotificationConfigurationRequestT& request) const {
    return SubmitCallable(&NotificationsClient::GetNotificationConfiguration, request);
  }
 
  template <typename GetNotificationConfigurationRequestT = Model::GetNotificationConfigurationRequest>
  void GetNotificationConfigurationAsync(const GetNotificationConfigurationRequestT& request,
                                         const GetNotificationConfigurationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::GetNotificationConfiguration, request, handler, context);
  }
 
  virtual Model::GetNotificationEventOutcome GetNotificationEvent(const Model::GetNotificationEventRequest& request) const;
 
  template <typename GetNotificationEventRequestT = Model::GetNotificationEventRequest>
  Model::GetNotificationEventOutcomeCallable GetNotificationEventCallable(const GetNotificationEventRequestT& request) const {
    return SubmitCallable(&NotificationsClient::GetNotificationEvent, request);
  }
 
  template <typename GetNotificationEventRequestT = Model::GetNotificationEventRequest>
  void GetNotificationEventAsync(const GetNotificationEventRequestT& request, const GetNotificationEventResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::GetNotificationEvent, request, handler, context);
  }
 
  virtual Model::GetNotificationsAccessForOrganizationOutcome GetNotificationsAccessForOrganization(
      const Model::GetNotificationsAccessForOrganizationRequest& request = {}) const;
 
  template <typename GetNotificationsAccessForOrganizationRequestT = Model::GetNotificationsAccessForOrganizationRequest>
  Model::GetNotificationsAccessForOrganizationOutcomeCallable GetNotificationsAccessForOrganizationCallable(
      const GetNotificationsAccessForOrganizationRequestT& request = {}) const {
    return SubmitCallable(&NotificationsClient::GetNotificationsAccessForOrganization, request);
  }
 
  template <typename GetNotificationsAccessForOrganizationRequestT = Model::GetNotificationsAccessForOrganizationRequest>
  void GetNotificationsAccessForOrganizationAsync(const GetNotificationsAccessForOrganizationResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                  const GetNotificationsAccessForOrganizationRequestT& request = {}) const {
    return SubmitAsync(&NotificationsClient::GetNotificationsAccessForOrganization, request, handler, context);
  }
 
  virtual Model::ListChannelsOutcome ListChannels(const Model::ListChannelsRequest& request) const;
 
  template <typename ListChannelsRequestT = Model::ListChannelsRequest>
  Model::ListChannelsOutcomeCallable ListChannelsCallable(const ListChannelsRequestT& request) const {
    return SubmitCallable(&NotificationsClient::ListChannels, request);
  }
 
  template <typename ListChannelsRequestT = Model::ListChannelsRequest>
  void ListChannelsAsync(const ListChannelsRequestT& request, const ListChannelsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::ListChannels, request, handler, context);
  }
 
  virtual Model::ListEventRulesOutcome ListEventRules(const Model::ListEventRulesRequest& request) const;
 
  template <typename ListEventRulesRequestT = Model::ListEventRulesRequest>
  Model::ListEventRulesOutcomeCallable ListEventRulesCallable(const ListEventRulesRequestT& request) const {
    return SubmitCallable(&NotificationsClient::ListEventRules, request);
  }
 
  template <typename ListEventRulesRequestT = Model::ListEventRulesRequest>
  void ListEventRulesAsync(const ListEventRulesRequestT& request, const ListEventRulesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::ListEventRules, request, handler, context);
  }
 
  virtual Model::ListManagedNotificationChannelAssociationsOutcome ListManagedNotificationChannelAssociations(
      const Model::ListManagedNotificationChannelAssociationsRequest& request) const;
 
  template <typename ListManagedNotificationChannelAssociationsRequestT = Model::ListManagedNotificationChannelAssociationsRequest>
  Model::ListManagedNotificationChannelAssociationsOutcomeCallable ListManagedNotificationChannelAssociationsCallable(
      const ListManagedNotificationChannelAssociationsRequestT& request) const {
    return SubmitCallable(&NotificationsClient::ListManagedNotificationChannelAssociations, request);
  }
 
  template <typename ListManagedNotificationChannelAssociationsRequestT = Model::ListManagedNotificationChannelAssociationsRequest>
  void ListManagedNotificationChannelAssociationsAsync(
      const ListManagedNotificationChannelAssociationsRequestT& request,
      const ListManagedNotificationChannelAssociationsResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::ListManagedNotificationChannelAssociations, request, handler, context);
  }
 
  virtual Model::ListManagedNotificationChildEventsOutcome ListManagedNotificationChildEvents(
      const Model::ListManagedNotificationChildEventsRequest& request) const;
 
  template <typename ListManagedNotificationChildEventsRequestT = Model::ListManagedNotificationChildEventsRequest>
  Model::ListManagedNotificationChildEventsOutcomeCallable ListManagedNotificationChildEventsCallable(
      const ListManagedNotificationChildEventsRequestT& request) const {
    return SubmitCallable(&NotificationsClient::ListManagedNotificationChildEvents, request);
  }
 
  template <typename ListManagedNotificationChildEventsRequestT = Model::ListManagedNotificationChildEventsRequest>
  void ListManagedNotificationChildEventsAsync(const ListManagedNotificationChildEventsRequestT& request,
                                               const ListManagedNotificationChildEventsResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::ListManagedNotificationChildEvents, request, handler, context);
  }
 
  virtual Model::ListManagedNotificationConfigurationsOutcome ListManagedNotificationConfigurations(
      const Model::ListManagedNotificationConfigurationsRequest& request = {}) const;
 
  template <typename ListManagedNotificationConfigurationsRequestT = Model::ListManagedNotificationConfigurationsRequest>
  Model::ListManagedNotificationConfigurationsOutcomeCallable ListManagedNotificationConfigurationsCallable(
      const ListManagedNotificationConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&NotificationsClient::ListManagedNotificationConfigurations, request);
  }
 
  template <typename ListManagedNotificationConfigurationsRequestT = Model::ListManagedNotificationConfigurationsRequest>
  void ListManagedNotificationConfigurationsAsync(const ListManagedNotificationConfigurationsResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                  const ListManagedNotificationConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&NotificationsClient::ListManagedNotificationConfigurations, request, handler, context);
  }
 
  virtual Model::ListManagedNotificationEventsOutcome ListManagedNotificationEvents(
      const Model::ListManagedNotificationEventsRequest& request = {}) const;
 
  template <typename ListManagedNotificationEventsRequestT = Model::ListManagedNotificationEventsRequest>
  Model::ListManagedNotificationEventsOutcomeCallable ListManagedNotificationEventsCallable(
      const ListManagedNotificationEventsRequestT& request = {}) const {
    return SubmitCallable(&NotificationsClient::ListManagedNotificationEvents, request);
  }
 
  template <typename ListManagedNotificationEventsRequestT = Model::ListManagedNotificationEventsRequest>
  void ListManagedNotificationEventsAsync(const ListManagedNotificationEventsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const ListManagedNotificationEventsRequestT& request = {}) const {
    return SubmitAsync(&NotificationsClient::ListManagedNotificationEvents, request, handler, context);
  }
 
  virtual Model::ListMemberAccountsOutcome ListMemberAccounts(const Model::ListMemberAccountsRequest& request) const;
 
  template <typename ListMemberAccountsRequestT = Model::ListMemberAccountsRequest>
  Model::ListMemberAccountsOutcomeCallable ListMemberAccountsCallable(const ListMemberAccountsRequestT& request) const {
    return SubmitCallable(&NotificationsClient::ListMemberAccounts, request);
  }
 
  template <typename ListMemberAccountsRequestT = Model::ListMemberAccountsRequest>
  void ListMemberAccountsAsync(const ListMemberAccountsRequestT& request, const ListMemberAccountsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::ListMemberAccounts, request, handler, context);
  }
 
  virtual Model::ListNotificationConfigurationsOutcome ListNotificationConfigurations(
      const Model::ListNotificationConfigurationsRequest& request = {}) const;
 
  template <typename ListNotificationConfigurationsRequestT = Model::ListNotificationConfigurationsRequest>
  Model::ListNotificationConfigurationsOutcomeCallable ListNotificationConfigurationsCallable(
      const ListNotificationConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&NotificationsClient::ListNotificationConfigurations, request);
  }
 
  template <typename ListNotificationConfigurationsRequestT = Model::ListNotificationConfigurationsRequest>
  void ListNotificationConfigurationsAsync(const ListNotificationConfigurationsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const ListNotificationConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&NotificationsClient::ListNotificationConfigurations, request, handler, context);
  }
 
  virtual Model::ListNotificationEventsOutcome ListNotificationEvents(const Model::ListNotificationEventsRequest& request = {}) const;
 
  template <typename ListNotificationEventsRequestT = Model::ListNotificationEventsRequest>
  Model::ListNotificationEventsOutcomeCallable ListNotificationEventsCallable(const ListNotificationEventsRequestT& request = {}) const {
    return SubmitCallable(&NotificationsClient::ListNotificationEvents, request);
  }
 
  template <typename ListNotificationEventsRequestT = Model::ListNotificationEventsRequest>
  void ListNotificationEventsAsync(const ListNotificationEventsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListNotificationEventsRequestT& request = {}) const {
    return SubmitAsync(&NotificationsClient::ListNotificationEvents, request, handler, context);
  }
 
  virtual Model::ListNotificationHubsOutcome ListNotificationHubs(const Model::ListNotificationHubsRequest& request = {}) const;
 
  template <typename ListNotificationHubsRequestT = Model::ListNotificationHubsRequest>
  Model::ListNotificationHubsOutcomeCallable ListNotificationHubsCallable(const ListNotificationHubsRequestT& request = {}) const {
    return SubmitCallable(&NotificationsClient::ListNotificationHubs, request);
  }
 
  template <typename ListNotificationHubsRequestT = Model::ListNotificationHubsRequest>
  void ListNotificationHubsAsync(const ListNotificationHubsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListNotificationHubsRequestT& request = {}) const {
    return SubmitAsync(&NotificationsClient::ListNotificationHubs, request, handler, context);
  }
 
  virtual Model::ListOrganizationalUnitsOutcome ListOrganizationalUnits(const Model::ListOrganizationalUnitsRequest& request) const;
 
  template <typename ListOrganizationalUnitsRequestT = Model::ListOrganizationalUnitsRequest>
  Model::ListOrganizationalUnitsOutcomeCallable ListOrganizationalUnitsCallable(const ListOrganizationalUnitsRequestT& request) const {
    return SubmitCallable(&NotificationsClient::ListOrganizationalUnits, request);
  }
 
  template <typename ListOrganizationalUnitsRequestT = Model::ListOrganizationalUnitsRequest>
  void ListOrganizationalUnitsAsync(const ListOrganizationalUnitsRequestT& request,
                                    const ListOrganizationalUnitsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::ListOrganizationalUnits, 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(&NotificationsClient::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(&NotificationsClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::RegisterNotificationHubOutcome RegisterNotificationHub(const Model::RegisterNotificationHubRequest& request) const;
 
  template <typename RegisterNotificationHubRequestT = Model::RegisterNotificationHubRequest>
  Model::RegisterNotificationHubOutcomeCallable RegisterNotificationHubCallable(const RegisterNotificationHubRequestT& request) const {
    return SubmitCallable(&NotificationsClient::RegisterNotificationHub, request);
  }
 
  template <typename RegisterNotificationHubRequestT = Model::RegisterNotificationHubRequest>
  void RegisterNotificationHubAsync(const RegisterNotificationHubRequestT& request,
                                    const RegisterNotificationHubResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::RegisterNotificationHub, 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(&NotificationsClient::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(&NotificationsClient::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(&NotificationsClient::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(&NotificationsClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateEventRuleOutcome UpdateEventRule(const Model::UpdateEventRuleRequest& request) const;
 
  template <typename UpdateEventRuleRequestT = Model::UpdateEventRuleRequest>
  Model::UpdateEventRuleOutcomeCallable UpdateEventRuleCallable(const UpdateEventRuleRequestT& request) const {
    return SubmitCallable(&NotificationsClient::UpdateEventRule, request);
  }
 
  template <typename UpdateEventRuleRequestT = Model::UpdateEventRuleRequest>
  void UpdateEventRuleAsync(const UpdateEventRuleRequestT& request, const UpdateEventRuleResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::UpdateEventRule, request, handler, context);
  }
 
  virtual Model::UpdateNotificationConfigurationOutcome UpdateNotificationConfiguration(
      const Model::UpdateNotificationConfigurationRequest& request) const;
 
  template <typename UpdateNotificationConfigurationRequestT = Model::UpdateNotificationConfigurationRequest>
  Model::UpdateNotificationConfigurationOutcomeCallable UpdateNotificationConfigurationCallable(
      const UpdateNotificationConfigurationRequestT& request) const {
    return SubmitCallable(&NotificationsClient::UpdateNotificationConfiguration, request);
  }
 
  template <typename UpdateNotificationConfigurationRequestT = Model::UpdateNotificationConfigurationRequest>
  void UpdateNotificationConfigurationAsync(const UpdateNotificationConfigurationRequestT& request,
                                            const UpdateNotificationConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NotificationsClient::UpdateNotificationConfiguration, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<NotificationsEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<NotificationsClient>;
  void init(const NotificationsClientConfiguration& clientConfiguration);
 
  NotificationsClientConfiguration m_clientConfiguration;
  std::shared_ptr<NotificationsEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Notifications
}  // namespace Aws