NotificationsClient.h

 
#pragma once
#include <aws/notifications/Notifications_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/notifications/NotificationsServiceClientModel.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::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::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::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::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