Package software.amazon.awssdk.services.notifications

Interface NotificationsAsyncClient

  • All Superinterfaces:
    AutoCloseable, AwsClient, SdkAutoCloseable, SdkClient
    @Generated("software.amazon.awssdk:codegen")
@ThreadSafe
public interface NotificationsAsyncClient
extends AwsClient
    Service client for accessing AWS User Notifications asynchronously. This can be created using the static builder() method.The asynchronous client performs non-blocking I/O when configured with any SdkAsyncHttpClient supported in the SDK. However, full non-blocking is not guaranteed as the async client may perform blocking calls in some cases such as credentials retrieval and endpoint discovery as part of the async API call.

    The Amazon Web Services User Notifications API Reference provides descriptions, API request parameters, and the JSON response for each of the User Notification API actions.

    User Notification control plane APIs are currently available in US East (Virginia) - us-east-1.

    GetNotificationEvent and ListNotificationEvents APIs are currently available in commercial partition Regions and only return notifications stored in the same Region in which they're called.

    The User Notifications console can only be used in US East (Virginia). Your data however, is stored in each Region chosen as a notification hub in addition to US East (Virginia).

    • Method Detail

      • associateChannel

        default CompletableFuture<AssociateChannelResponse> associateChannel​(AssociateChannelRequest associateChannelRequest)

        Associates a delivery Channel with a particular NotificationConfiguration. Supported Channels include Chatbot, the Console Mobile Application, and emails (notifications-contacts).

        Parameters:
        associateChannelRequest -
        Returns:
        A Java Future containing the result of the AssociateChannel operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceQuotaExceededException Request would cause a service quota to be exceeded.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • associateChannel

        default CompletableFuture<AssociateChannelResponse> associateChannel​(Consumer<AssociateChannelRequest.Builder> associateChannelRequest)

        Associates a delivery Channel with a particular NotificationConfiguration. Supported Channels include Chatbot, the Console Mobile Application, and emails (notifications-contacts).


        This is a convenience which creates an instance of the AssociateChannelRequest.Builder avoiding the need to create one manually via AssociateChannelRequest.builder()

        Parameters:
        associateChannelRequest - A Consumer that will call methods on AssociateChannelRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the AssociateChannel operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceQuotaExceededException Request would cause a service quota to be exceeded.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • associateManagedNotificationAccountContact

        default CompletableFuture<AssociateManagedNotificationAccountContactResponse> associateManagedNotificationAccountContact​(AssociateManagedNotificationAccountContactRequest associateManagedNotificationAccountContactRequest)

        Associates an Account Contact with a particular ManagedNotificationConfiguration.

        Parameters:
        associateManagedNotificationAccountContactRequest -
        Returns:
        A Java Future containing the result of the AssociateManagedNotificationAccountContact operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceQuotaExceededException Request would cause a service quota to be exceeded.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • associateManagedNotificationAccountContact

        default CompletableFuture<AssociateManagedNotificationAccountContactResponse> associateManagedNotificationAccountContact​(Consumer<AssociateManagedNotificationAccountContactRequest.Builder> associateManagedNotificationAccountContactRequest)

        Associates an Account Contact with a particular ManagedNotificationConfiguration.


        This is a convenience which creates an instance of the AssociateManagedNotificationAccountContactRequest.Builder avoiding the need to create one manually via AssociateManagedNotificationAccountContactRequest.builder()

        Parameters:
        associateManagedNotificationAccountContactRequest - A Consumer that will call methods on AssociateManagedNotificationAccountContactRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the AssociateManagedNotificationAccountContact operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceQuotaExceededException Request would cause a service quota to be exceeded.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • associateManagedNotificationAdditionalChannel

        default CompletableFuture<AssociateManagedNotificationAdditionalChannelResponse> associateManagedNotificationAdditionalChannel​(AssociateManagedNotificationAdditionalChannelRequest associateManagedNotificationAdditionalChannelRequest)

        Associates an additional Channel with a particular ManagedNotificationConfiguration.

        Supported Channels include Chatbot, the Console Mobile Application, and emails (notifications-contacts).

        Parameters:
        associateManagedNotificationAdditionalChannelRequest -
        Returns:
        A Java Future containing the result of the AssociateManagedNotificationAdditionalChannel operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceQuotaExceededException Request would cause a service quota to be exceeded.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • associateManagedNotificationAdditionalChannel

        default CompletableFuture<AssociateManagedNotificationAdditionalChannelResponse> associateManagedNotificationAdditionalChannel​(Consumer<AssociateManagedNotificationAdditionalChannelRequest.Builder> associateManagedNotificationAdditionalChannelRequest)

        Associates an additional Channel with a particular ManagedNotificationConfiguration.

        Supported Channels include Chatbot, the Console Mobile Application, and emails (notifications-contacts).


        This is a convenience which creates an instance of the AssociateManagedNotificationAdditionalChannelRequest.Builder avoiding the need to create one manually via AssociateManagedNotificationAdditionalChannelRequest.builder()

        Parameters:
        associateManagedNotificationAdditionalChannelRequest - A Consumer that will call methods on AssociateManagedNotificationAdditionalChannelRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the AssociateManagedNotificationAdditionalChannel operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceQuotaExceededException Request would cause a service quota to be exceeded.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createEventRule

        default CompletableFuture<CreateEventRuleResponse> createEventRule​(CreateEventRuleRequest createEventRuleRequest)

        Creates an EventRule that is associated with a specified NotificationConfiguration.

        Parameters:
        createEventRuleRequest -
        Returns:
        A Java Future containing the result of the CreateEventRule operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceQuotaExceededException Request would cause a service quota to be exceeded.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createEventRule

        default CompletableFuture<CreateEventRuleResponse> createEventRule​(Consumer<CreateEventRuleRequest.Builder> createEventRuleRequest)

        Creates an EventRule that is associated with a specified NotificationConfiguration.


        This is a convenience which creates an instance of the CreateEventRuleRequest.Builder avoiding the need to create one manually via CreateEventRuleRequest.builder()

        Parameters:
        createEventRuleRequest - A Consumer that will call methods on CreateEventRuleRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the CreateEventRule operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceQuotaExceededException Request would cause a service quota to be exceeded.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createNotificationConfiguration

        default CompletableFuture<CreateNotificationConfigurationResponse> createNotificationConfiguration​(CreateNotificationConfigurationRequest createNotificationConfigurationRequest)

        Creates a new NotificationConfiguration.

        Parameters:
        createNotificationConfigurationRequest -
        Returns:
        A Java Future containing the result of the CreateNotificationConfiguration operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceQuotaExceededException Request would cause a service quota to be exceeded.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • createNotificationConfiguration

        default CompletableFuture<CreateNotificationConfigurationResponse> createNotificationConfiguration​(Consumer<CreateNotificationConfigurationRequest.Builder> createNotificationConfigurationRequest)

        Creates a new NotificationConfiguration.


        This is a convenience which creates an instance of the CreateNotificationConfigurationRequest.Builder avoiding the need to create one manually via CreateNotificationConfigurationRequest.builder()

        Parameters:
        createNotificationConfigurationRequest - A Consumer that will call methods on CreateNotificationConfigurationRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the CreateNotificationConfiguration operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceQuotaExceededException Request would cause a service quota to be exceeded.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteEventRule

        default CompletableFuture<DeleteEventRuleResponse> deleteEventRule​(DeleteEventRuleRequest deleteEventRuleRequest)

        Deletes an EventRule.

        Parameters:
        deleteEventRuleRequest -
        Returns:
        A Java Future containing the result of the DeleteEventRule operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteEventRule

        default CompletableFuture<DeleteEventRuleResponse> deleteEventRule​(Consumer<DeleteEventRuleRequest.Builder> deleteEventRuleRequest)

        Deletes an EventRule.


        This is a convenience which creates an instance of the DeleteEventRuleRequest.Builder avoiding the need to create one manually via DeleteEventRuleRequest.builder()

        Parameters:
        deleteEventRuleRequest - A Consumer that will call methods on DeleteEventRuleRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DeleteEventRule operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteNotificationConfiguration

        default CompletableFuture<DeleteNotificationConfigurationResponse> deleteNotificationConfiguration​(DeleteNotificationConfigurationRequest deleteNotificationConfigurationRequest)

        Deletes a NotificationConfiguration.

        Parameters:
        deleteNotificationConfigurationRequest -
        Returns:
        A Java Future containing the result of the DeleteNotificationConfiguration operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deleteNotificationConfiguration

        default CompletableFuture<DeleteNotificationConfigurationResponse> deleteNotificationConfiguration​(Consumer<DeleteNotificationConfigurationRequest.Builder> deleteNotificationConfigurationRequest)

        Deletes a NotificationConfiguration.


        This is a convenience which creates an instance of the DeleteNotificationConfigurationRequest.Builder avoiding the need to create one manually via DeleteNotificationConfigurationRequest.builder()

        Parameters:
        deleteNotificationConfigurationRequest - A Consumer that will call methods on DeleteNotificationConfigurationRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DeleteNotificationConfiguration operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deregisterNotificationHub

        default CompletableFuture<DeregisterNotificationHubResponse> deregisterNotificationHub​(DeregisterNotificationHubRequest deregisterNotificationHubRequest)

        Deregisters a NotificationConfiguration in the specified Region.

        You can't deregister the last NotificationHub in the account. NotificationEvents stored in the deregistered NotificationConfiguration are no longer be visible. Recreating a new NotificationConfiguration in the same Region restores access to those NotificationEvents.

        Parameters:
        deregisterNotificationHubRequest -
        Returns:
        A Java Future containing the result of the DeregisterNotificationHub operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • deregisterNotificationHub

        default CompletableFuture<DeregisterNotificationHubResponse> deregisterNotificationHub​(Consumer<DeregisterNotificationHubRequest.Builder> deregisterNotificationHubRequest)

        Deregisters a NotificationConfiguration in the specified Region.

        You can't deregister the last NotificationHub in the account. NotificationEvents stored in the deregistered NotificationConfiguration are no longer be visible. Recreating a new NotificationConfiguration in the same Region restores access to those NotificationEvents.


        This is a convenience which creates an instance of the DeregisterNotificationHubRequest.Builder avoiding the need to create one manually via DeregisterNotificationHubRequest.builder()

        Parameters:
        deregisterNotificationHubRequest - A Consumer that will call methods on DeregisterNotificationHubRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DeregisterNotificationHub operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • disableNotificationsAccessForOrganization

        default CompletableFuture<DisableNotificationsAccessForOrganizationResponse> disableNotificationsAccessForOrganization​(DisableNotificationsAccessForOrganizationRequest disableNotificationsAccessForOrganizationRequest)

        Disables service trust between User Notifications and Amazon Web Services Organizations.

        Parameters:
        disableNotificationsAccessForOrganizationRequest -
        Returns:
        A Java Future containing the result of the DisableNotificationsAccessForOrganization operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceQuotaExceededException Request would cause a service quota to be exceeded.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • disableNotificationsAccessForOrganization

        default CompletableFuture<DisableNotificationsAccessForOrganizationResponse> disableNotificationsAccessForOrganization​(Consumer<DisableNotificationsAccessForOrganizationRequest.Builder> disableNotificationsAccessForOrganizationRequest)

        Disables service trust between User Notifications and Amazon Web Services Organizations.


        This is a convenience which creates an instance of the DisableNotificationsAccessForOrganizationRequest.Builder avoiding the need to create one manually via DisableNotificationsAccessForOrganizationRequest.builder()

        Parameters:
        disableNotificationsAccessForOrganizationRequest - A Consumer that will call methods on DisableNotificationsAccessForOrganizationRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DisableNotificationsAccessForOrganization operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceQuotaExceededException Request would cause a service quota to be exceeded.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • disassociateChannel

        default CompletableFuture<DisassociateChannelResponse> disassociateChannel​(DisassociateChannelRequest disassociateChannelRequest)

        Disassociates a Channel from a specified NotificationConfiguration. Supported Channels include Chatbot, the Console Mobile Application, and emails (notifications-contacts).

        Parameters:
        disassociateChannelRequest -
        Returns:
        A Java Future containing the result of the DisassociateChannel operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • disassociateChannel

        default CompletableFuture<DisassociateChannelResponse> disassociateChannel​(Consumer<DisassociateChannelRequest.Builder> disassociateChannelRequest)

        Disassociates a Channel from a specified NotificationConfiguration. Supported Channels include Chatbot, the Console Mobile Application, and emails (notifications-contacts).


        This is a convenience which creates an instance of the DisassociateChannelRequest.Builder avoiding the need to create one manually via DisassociateChannelRequest.builder()

        Parameters:
        disassociateChannelRequest - A Consumer that will call methods on DisassociateChannelRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DisassociateChannel operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • disassociateManagedNotificationAccountContact

        default CompletableFuture<DisassociateManagedNotificationAccountContactResponse> disassociateManagedNotificationAccountContact​(DisassociateManagedNotificationAccountContactRequest disassociateManagedNotificationAccountContactRequest)

        Disassociates an Account Contact with a particular ManagedNotificationConfiguration.

        Parameters:
        disassociateManagedNotificationAccountContactRequest -
        Returns:
        A Java Future containing the result of the DisassociateManagedNotificationAccountContact operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • disassociateManagedNotificationAccountContact

        default CompletableFuture<DisassociateManagedNotificationAccountContactResponse> disassociateManagedNotificationAccountContact​(Consumer<DisassociateManagedNotificationAccountContactRequest.Builder> disassociateManagedNotificationAccountContactRequest)

        Disassociates an Account Contact with a particular ManagedNotificationConfiguration.


        This is a convenience which creates an instance of the DisassociateManagedNotificationAccountContactRequest.Builder avoiding the need to create one manually via DisassociateManagedNotificationAccountContactRequest.builder()

        Parameters:
        disassociateManagedNotificationAccountContactRequest - A Consumer that will call methods on DisassociateManagedNotificationAccountContactRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DisassociateManagedNotificationAccountContact operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • disassociateManagedNotificationAdditionalChannel

        default CompletableFuture<DisassociateManagedNotificationAdditionalChannelResponse> disassociateManagedNotificationAdditionalChannel​(DisassociateManagedNotificationAdditionalChannelRequest disassociateManagedNotificationAdditionalChannelRequest)

        Disassociates an additional Channel from a particular ManagedNotificationConfiguration.

        Supported Channels include Chatbot, the Console Mobile Application, and emails (notifications-contacts).

        Parameters:
        disassociateManagedNotificationAdditionalChannelRequest -
        Returns:
        A Java Future containing the result of the DisassociateManagedNotificationAdditionalChannel operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • disassociateManagedNotificationAdditionalChannel

        default CompletableFuture<DisassociateManagedNotificationAdditionalChannelResponse> disassociateManagedNotificationAdditionalChannel​(Consumer<DisassociateManagedNotificationAdditionalChannelRequest.Builder> disassociateManagedNotificationAdditionalChannelRequest)

        Disassociates an additional Channel from a particular ManagedNotificationConfiguration.

        Supported Channels include Chatbot, the Console Mobile Application, and emails (notifications-contacts).


        This is a convenience which creates an instance of the DisassociateManagedNotificationAdditionalChannelRequest.Builder avoiding the need to create one manually via DisassociateManagedNotificationAdditionalChannelRequest.builder()

        Parameters:
        disassociateManagedNotificationAdditionalChannelRequest - A Consumer that will call methods on DisassociateManagedNotificationAdditionalChannelRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the DisassociateManagedNotificationAdditionalChannel operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • enableNotificationsAccessForOrganization

        default CompletableFuture<EnableNotificationsAccessForOrganizationResponse> enableNotificationsAccessForOrganization​(EnableNotificationsAccessForOrganizationRequest enableNotificationsAccessForOrganizationRequest)

        Enables service trust between User Notifications and Amazon Web Services Organizations.

        Parameters:
        enableNotificationsAccessForOrganizationRequest -
        Returns:
        A Java Future containing the result of the EnableNotificationsAccessForOrganization operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceQuotaExceededException Request would cause a service quota to be exceeded.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • enableNotificationsAccessForOrganization

        default CompletableFuture<EnableNotificationsAccessForOrganizationResponse> enableNotificationsAccessForOrganization​(Consumer<EnableNotificationsAccessForOrganizationRequest.Builder> enableNotificationsAccessForOrganizationRequest)

        Enables service trust between User Notifications and Amazon Web Services Organizations.


        This is a convenience which creates an instance of the EnableNotificationsAccessForOrganizationRequest.Builder avoiding the need to create one manually via EnableNotificationsAccessForOrganizationRequest.builder()

        Parameters:
        enableNotificationsAccessForOrganizationRequest - A Consumer that will call methods on EnableNotificationsAccessForOrganizationRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the EnableNotificationsAccessForOrganization operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceQuotaExceededException Request would cause a service quota to be exceeded.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getEventRule

        default CompletableFuture<GetEventRuleResponse> getEventRule​(GetEventRuleRequest getEventRuleRequest)

        Returns a specified EventRule.

        Parameters:
        getEventRuleRequest -
        Returns:
        A Java Future containing the result of the GetEventRule operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getEventRule

        default CompletableFuture<GetEventRuleResponse> getEventRule​(Consumer<GetEventRuleRequest.Builder> getEventRuleRequest)

        Returns a specified EventRule.


        This is a convenience which creates an instance of the GetEventRuleRequest.Builder avoiding the need to create one manually via GetEventRuleRequest.builder()

        Parameters:
        getEventRuleRequest - A Consumer that will call methods on GetEventRuleRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the GetEventRule operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getManagedNotificationChildEvent

        default CompletableFuture<GetManagedNotificationChildEventResponse> getManagedNotificationChildEvent​(GetManagedNotificationChildEventRequest getManagedNotificationChildEventRequest)

        Returns the child event of a specific given ManagedNotificationEvent.

        Parameters:
        getManagedNotificationChildEventRequest -
        Returns:
        A Java Future containing the result of the GetManagedNotificationChildEvent operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getManagedNotificationChildEvent

        default CompletableFuture<GetManagedNotificationChildEventResponse> getManagedNotificationChildEvent​(Consumer<GetManagedNotificationChildEventRequest.Builder> getManagedNotificationChildEventRequest)

        Returns the child event of a specific given ManagedNotificationEvent.


        This is a convenience which creates an instance of the GetManagedNotificationChildEventRequest.Builder avoiding the need to create one manually via GetManagedNotificationChildEventRequest.builder()

        Parameters:
        getManagedNotificationChildEventRequest - A Consumer that will call methods on GetManagedNotificationChildEventRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the GetManagedNotificationChildEvent operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getManagedNotificationConfiguration

        default CompletableFuture<GetManagedNotificationConfigurationResponse> getManagedNotificationConfiguration​(GetManagedNotificationConfigurationRequest getManagedNotificationConfigurationRequest)

        Returns a specified ManagedNotificationConfiguration.

        Parameters:
        getManagedNotificationConfigurationRequest -
        Returns:
        A Java Future containing the result of the GetManagedNotificationConfiguration operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getManagedNotificationConfiguration

        default CompletableFuture<GetManagedNotificationConfigurationResponse> getManagedNotificationConfiguration​(Consumer<GetManagedNotificationConfigurationRequest.Builder> getManagedNotificationConfigurationRequest)

        Returns a specified ManagedNotificationConfiguration.


        This is a convenience which creates an instance of the GetManagedNotificationConfigurationRequest.Builder avoiding the need to create one manually via GetManagedNotificationConfigurationRequest.builder()

        Parameters:
        getManagedNotificationConfigurationRequest - A Consumer that will call methods on GetManagedNotificationConfigurationRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the GetManagedNotificationConfiguration operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getManagedNotificationEvent

        default CompletableFuture<GetManagedNotificationEventResponse> getManagedNotificationEvent​(GetManagedNotificationEventRequest getManagedNotificationEventRequest)

        Returns a specified ManagedNotificationEvent.

        Parameters:
        getManagedNotificationEventRequest -
        Returns:
        A Java Future containing the result of the GetManagedNotificationEvent operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getManagedNotificationEvent

        default CompletableFuture<GetManagedNotificationEventResponse> getManagedNotificationEvent​(Consumer<GetManagedNotificationEventRequest.Builder> getManagedNotificationEventRequest)

        Returns a specified ManagedNotificationEvent.


        This is a convenience which creates an instance of the GetManagedNotificationEventRequest.Builder avoiding the need to create one manually via GetManagedNotificationEventRequest.builder()

        Parameters:
        getManagedNotificationEventRequest - A Consumer that will call methods on GetManagedNotificationEventRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the GetManagedNotificationEvent operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getNotificationConfiguration

        default CompletableFuture<GetNotificationConfigurationResponse> getNotificationConfiguration​(GetNotificationConfigurationRequest getNotificationConfigurationRequest)

        Returns a specified NotificationConfiguration.

        Parameters:
        getNotificationConfigurationRequest -
        Returns:
        A Java Future containing the result of the GetNotificationConfiguration operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getNotificationConfiguration

        default CompletableFuture<GetNotificationConfigurationResponse> getNotificationConfiguration​(Consumer<GetNotificationConfigurationRequest.Builder> getNotificationConfigurationRequest)

        Returns a specified NotificationConfiguration.


        This is a convenience which creates an instance of the GetNotificationConfigurationRequest.Builder avoiding the need to create one manually via GetNotificationConfigurationRequest.builder()

        Parameters:
        getNotificationConfigurationRequest - A Consumer that will call methods on GetNotificationConfigurationRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the GetNotificationConfiguration operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getNotificationEvent

        default CompletableFuture<GetNotificationEventResponse> getNotificationEvent​(GetNotificationEventRequest getNotificationEventRequest)

        Returns a specified NotificationEvent.

        User Notifications stores notifications in the individual Regions you register as notification hubs and the Region of the source event rule. GetNotificationEvent only returns notifications stored in the same Region in which the action is called. User Notifications doesn't backfill notifications to new Regions selected as notification hubs. For this reason, we recommend that you make calls in your oldest registered notification hub. For more information, see Notification hubs in the Amazon Web Services User Notifications User Guide.

        Parameters:
        getNotificationEventRequest -
        Returns:
        A Java Future containing the result of the GetNotificationEvent operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getNotificationEvent

        default CompletableFuture<GetNotificationEventResponse> getNotificationEvent​(Consumer<GetNotificationEventRequest.Builder> getNotificationEventRequest)

        Returns a specified NotificationEvent.

        User Notifications stores notifications in the individual Regions you register as notification hubs and the Region of the source event rule. GetNotificationEvent only returns notifications stored in the same Region in which the action is called. User Notifications doesn't backfill notifications to new Regions selected as notification hubs. For this reason, we recommend that you make calls in your oldest registered notification hub. For more information, see Notification hubs in the Amazon Web Services User Notifications User Guide.


        This is a convenience which creates an instance of the GetNotificationEventRequest.Builder avoiding the need to create one manually via GetNotificationEventRequest.builder()

        Parameters:
        getNotificationEventRequest - A Consumer that will call methods on GetNotificationEventRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the GetNotificationEvent operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getNotificationsAccessForOrganization

        default CompletableFuture<GetNotificationsAccessForOrganizationResponse> getNotificationsAccessForOrganization​(GetNotificationsAccessForOrganizationRequest getNotificationsAccessForOrganizationRequest)

        Returns the AccessStatus of Service Trust Enablement for User Notifications and Amazon Web Services Organizations.

        Parameters:
        getNotificationsAccessForOrganizationRequest -
        Returns:
        A Java Future containing the result of the GetNotificationsAccessForOrganization operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • getNotificationsAccessForOrganization

        default CompletableFuture<GetNotificationsAccessForOrganizationResponse> getNotificationsAccessForOrganization​(Consumer<GetNotificationsAccessForOrganizationRequest.Builder> getNotificationsAccessForOrganizationRequest)

        Returns the AccessStatus of Service Trust Enablement for User Notifications and Amazon Web Services Organizations.


        This is a convenience which creates an instance of the GetNotificationsAccessForOrganizationRequest.Builder avoiding the need to create one manually via GetNotificationsAccessForOrganizationRequest.builder()

        Parameters:
        getNotificationsAccessForOrganizationRequest - A Consumer that will call methods on GetNotificationsAccessForOrganizationRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the GetNotificationsAccessForOrganization operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listChannels

        default CompletableFuture<ListChannelsResponse> listChannels​(ListChannelsRequest listChannelsRequest)

        Returns a list of Channels for a NotificationConfiguration.

        Parameters:
        listChannelsRequest -
        Returns:
        A Java Future containing the result of the ListChannels operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listChannels

        default CompletableFuture<ListChannelsResponse> listChannels​(Consumer<ListChannelsRequest.Builder> listChannelsRequest)

        Returns a list of Channels for a NotificationConfiguration.


        This is a convenience which creates an instance of the ListChannelsRequest.Builder avoiding the need to create one manually via ListChannelsRequest.builder()

        Parameters:
        listChannelsRequest - A Consumer that will call methods on ListChannelsRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListChannels operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listChannelsPaginator

        default ListChannelsPublisher listChannelsPaginator​(ListChannelsRequest listChannelsRequest)

        This is a variant of listChannels(software.amazon.awssdk.services.notifications.model.ListChannelsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

        When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

        The following are few ways to use the response class:

        1) Using the subscribe helper method 
         
 software.amazon.awssdk.services.notifications.paginators.ListChannelsPublisher publisher = client.listChannelsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.notifications.paginators.ListChannelsPublisher publisher = client.listChannelsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.notifications.model.ListChannelsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.notifications.model.ListChannelsResponse response) { //... };
 });
        As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

        Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

        Note: If you prefer to have control on service calls, use the listChannels(software.amazon.awssdk.services.notifications.model.ListChannelsRequest) operation.

        Parameters:
        listChannelsRequest -
        Returns:
        A custom publisher that can be subscribed to request a stream of response pages.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listChannelsPaginator

        default ListChannelsPublisher listChannelsPaginator​(Consumer<ListChannelsRequest.Builder> listChannelsRequest)

        This is a variant of listChannels(software.amazon.awssdk.services.notifications.model.ListChannelsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

        When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

        The following are few ways to use the response class:

        1) Using the subscribe helper method 
         
 software.amazon.awssdk.services.notifications.paginators.ListChannelsPublisher publisher = client.listChannelsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.notifications.paginators.ListChannelsPublisher publisher = client.listChannelsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.notifications.model.ListChannelsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.notifications.model.ListChannelsResponse response) { //... };
 });
        As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

        Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

        Note: If you prefer to have control on service calls, use the listChannels(software.amazon.awssdk.services.notifications.model.ListChannelsRequest) operation.


        This is a convenience which creates an instance of the ListChannelsRequest.Builder avoiding the need to create one manually via ListChannelsRequest.builder()

        Parameters:
        listChannelsRequest - A Consumer that will call methods on ListChannelsRequest.Builder to create a request.
        Returns:
        A custom publisher that can be subscribed to request a stream of response pages.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listEventRules

        default CompletableFuture<ListEventRulesResponse> listEventRules​(ListEventRulesRequest listEventRulesRequest)

        Returns a list of EventRules according to specified filters, in reverse chronological order (newest first).

        Parameters:
        listEventRulesRequest -
        Returns:
        A Java Future containing the result of the ListEventRules operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listEventRules

        default CompletableFuture<ListEventRulesResponse> listEventRules​(Consumer<ListEventRulesRequest.Builder> listEventRulesRequest)

        Returns a list of EventRules according to specified filters, in reverse chronological order (newest first).


        This is a convenience which creates an instance of the ListEventRulesRequest.Builder avoiding the need to create one manually via ListEventRulesRequest.builder()

        Parameters:
        listEventRulesRequest - A Consumer that will call methods on ListEventRulesRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListEventRules operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listEventRulesPaginator

        default ListEventRulesPublisher listEventRulesPaginator​(ListEventRulesRequest listEventRulesRequest)

        This is a variant of listEventRules(software.amazon.awssdk.services.notifications.model.ListEventRulesRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

        When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

        The following are few ways to use the response class:

        1) Using the subscribe helper method 
         
 software.amazon.awssdk.services.notifications.paginators.ListEventRulesPublisher publisher = client.listEventRulesPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.notifications.paginators.ListEventRulesPublisher publisher = client.listEventRulesPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.notifications.model.ListEventRulesResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.notifications.model.ListEventRulesResponse response) { //... };
 });
        As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

        Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

        Note: If you prefer to have control on service calls, use the listEventRules(software.amazon.awssdk.services.notifications.model.ListEventRulesRequest) operation.

        Parameters:
        listEventRulesRequest -
        Returns:
        A custom publisher that can be subscribed to request a stream of response pages.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listEventRulesPaginator

        default ListEventRulesPublisher listEventRulesPaginator​(Consumer<ListEventRulesRequest.Builder> listEventRulesRequest)

        This is a variant of listEventRules(software.amazon.awssdk.services.notifications.model.ListEventRulesRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

        When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

        The following are few ways to use the response class:

        1) Using the subscribe helper method 
         
 software.amazon.awssdk.services.notifications.paginators.ListEventRulesPublisher publisher = client.listEventRulesPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.notifications.paginators.ListEventRulesPublisher publisher = client.listEventRulesPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.notifications.model.ListEventRulesResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.notifications.model.ListEventRulesResponse response) { //... };
 });
        As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

        Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

        Note: If you prefer to have control on service calls, use the listEventRules(software.amazon.awssdk.services.notifications.model.ListEventRulesRequest) operation.


        This is a convenience which creates an instance of the ListEventRulesRequest.Builder avoiding the need to create one manually via ListEventRulesRequest.builder()

        Parameters:
        listEventRulesRequest - A Consumer that will call methods on ListEventRulesRequest.Builder to create a request.
        Returns:
        A custom publisher that can be subscribed to request a stream of response pages.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listManagedNotificationChannelAssociations

        default CompletableFuture<ListManagedNotificationChannelAssociationsResponse> listManagedNotificationChannelAssociations​(ListManagedNotificationChannelAssociationsRequest listManagedNotificationChannelAssociationsRequest)

        Returns a list of Account contacts and Channels associated with a ManagedNotificationConfiguration, in paginated format.

        Parameters:
        listManagedNotificationChannelAssociationsRequest -
        Returns:
        A Java Future containing the result of the ListManagedNotificationChannelAssociations operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listManagedNotificationChannelAssociations

        default CompletableFuture<ListManagedNotificationChannelAssociationsResponse> listManagedNotificationChannelAssociations​(Consumer<ListManagedNotificationChannelAssociationsRequest.Builder> listManagedNotificationChannelAssociationsRequest)

        Returns a list of Account contacts and Channels associated with a ManagedNotificationConfiguration, in paginated format.


        This is a convenience which creates an instance of the ListManagedNotificationChannelAssociationsRequest.Builder avoiding the need to create one manually via ListManagedNotificationChannelAssociationsRequest.builder()

        Parameters:
        listManagedNotificationChannelAssociationsRequest - A Consumer that will call methods on ListManagedNotificationChannelAssociationsRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListManagedNotificationChannelAssociations operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listManagedNotificationChannelAssociationsPaginator

        default ListManagedNotificationChannelAssociationsPublisher listManagedNotificationChannelAssociationsPaginator​(ListManagedNotificationChannelAssociationsRequest listManagedNotificationChannelAssociationsRequest)

        This is a variant of listManagedNotificationChannelAssociations(software.amazon.awssdk.services.notifications.model.ListManagedNotificationChannelAssociationsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

        When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

        The following are few ways to use the response class:

        1) Using the subscribe helper method 
         
 software.amazon.awssdk.services.notifications.paginators.ListManagedNotificationChannelAssociationsPublisher publisher = client.listManagedNotificationChannelAssociationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.notifications.paginators.ListManagedNotificationChannelAssociationsPublisher publisher = client.listManagedNotificationChannelAssociationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.notifications.model.ListManagedNotificationChannelAssociationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.notifications.model.ListManagedNotificationChannelAssociationsResponse response) { //... };
 });
        As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

        Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

        Note: If you prefer to have control on service calls, use the listManagedNotificationChannelAssociations(software.amazon.awssdk.services.notifications.model.ListManagedNotificationChannelAssociationsRequest) operation.

        Parameters:
        listManagedNotificationChannelAssociationsRequest -
        Returns:
        A custom publisher that can be subscribed to request a stream of response pages.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listManagedNotificationChannelAssociationsPaginator

        default ListManagedNotificationChannelAssociationsPublisher listManagedNotificationChannelAssociationsPaginator​(Consumer<ListManagedNotificationChannelAssociationsRequest.Builder> listManagedNotificationChannelAssociationsRequest)

        This is a variant of listManagedNotificationChannelAssociations(software.amazon.awssdk.services.notifications.model.ListManagedNotificationChannelAssociationsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

        When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

        The following are few ways to use the response class:

        1) Using the subscribe helper method 
         
 software.amazon.awssdk.services.notifications.paginators.ListManagedNotificationChannelAssociationsPublisher publisher = client.listManagedNotificationChannelAssociationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.notifications.paginators.ListManagedNotificationChannelAssociationsPublisher publisher = client.listManagedNotificationChannelAssociationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.notifications.model.ListManagedNotificationChannelAssociationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.notifications.model.ListManagedNotificationChannelAssociationsResponse response) { //... };
 });
        As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

        Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

        Note: If you prefer to have control on service calls, use the listManagedNotificationChannelAssociations(software.amazon.awssdk.services.notifications.model.ListManagedNotificationChannelAssociationsRequest) operation.


        This is a convenience which creates an instance of the ListManagedNotificationChannelAssociationsRequest.Builder avoiding the need to create one manually via ListManagedNotificationChannelAssociationsRequest.builder()

        Parameters:
        listManagedNotificationChannelAssociationsRequest - A Consumer that will call methods on ListManagedNotificationChannelAssociationsRequest.Builder to create a request.
        Returns:
        A custom publisher that can be subscribed to request a stream of response pages.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listManagedNotificationChildEvents

        default CompletableFuture<ListManagedNotificationChildEventsResponse> listManagedNotificationChildEvents​(ListManagedNotificationChildEventsRequest listManagedNotificationChildEventsRequest)

        Returns a list of ManagedNotificationChildEvents for a specified aggregate ManagedNotificationEvent, ordered by creation time in reverse chronological order (newest first).

        Parameters:
        listManagedNotificationChildEventsRequest -
        Returns:
        A Java Future containing the result of the ListManagedNotificationChildEvents operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listManagedNotificationChildEvents

        default CompletableFuture<ListManagedNotificationChildEventsResponse> listManagedNotificationChildEvents​(Consumer<ListManagedNotificationChildEventsRequest.Builder> listManagedNotificationChildEventsRequest)

        Returns a list of ManagedNotificationChildEvents for a specified aggregate ManagedNotificationEvent, ordered by creation time in reverse chronological order (newest first).


        This is a convenience which creates an instance of the ListManagedNotificationChildEventsRequest.Builder avoiding the need to create one manually via ListManagedNotificationChildEventsRequest.builder()

        Parameters:
        listManagedNotificationChildEventsRequest - A Consumer that will call methods on ListManagedNotificationChildEventsRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListManagedNotificationChildEvents operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listManagedNotificationChildEventsPaginator

        default ListManagedNotificationChildEventsPublisher listManagedNotificationChildEventsPaginator​(ListManagedNotificationChildEventsRequest listManagedNotificationChildEventsRequest)

        This is a variant of listManagedNotificationChildEvents(software.amazon.awssdk.services.notifications.model.ListManagedNotificationChildEventsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

        When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

        The following are few ways to use the response class:

        1) Using the subscribe helper method 
         
 software.amazon.awssdk.services.notifications.paginators.ListManagedNotificationChildEventsPublisher publisher = client.listManagedNotificationChildEventsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.notifications.paginators.ListManagedNotificationChildEventsPublisher publisher = client.listManagedNotificationChildEventsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.notifications.model.ListManagedNotificationChildEventsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.notifications.model.ListManagedNotificationChildEventsResponse response) { //... };
 });
        As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

        Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

        Note: If you prefer to have control on service calls, use the listManagedNotificationChildEvents(software.amazon.awssdk.services.notifications.model.ListManagedNotificationChildEventsRequest) operation.

        Parameters:
        listManagedNotificationChildEventsRequest -
        Returns:
        A custom publisher that can be subscribed to request a stream of response pages.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listManagedNotificationChildEventsPaginator

        default ListManagedNotificationChildEventsPublisher listManagedNotificationChildEventsPaginator​(Consumer<ListManagedNotificationChildEventsRequest.Builder> listManagedNotificationChildEventsRequest)

        This is a variant of listManagedNotificationChildEvents(software.amazon.awssdk.services.notifications.model.ListManagedNotificationChildEventsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

        When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

        The following are few ways to use the response class:

        1) Using the subscribe helper method 
         
 software.amazon.awssdk.services.notifications.paginators.ListManagedNotificationChildEventsPublisher publisher = client.listManagedNotificationChildEventsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.notifications.paginators.ListManagedNotificationChildEventsPublisher publisher = client.listManagedNotificationChildEventsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.notifications.model.ListManagedNotificationChildEventsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.notifications.model.ListManagedNotificationChildEventsResponse response) { //... };
 });
        As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

        Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

        Note: If you prefer to have control on service calls, use the listManagedNotificationChildEvents(software.amazon.awssdk.services.notifications.model.ListManagedNotificationChildEventsRequest) operation.


        This is a convenience which creates an instance of the ListManagedNotificationChildEventsRequest.Builder avoiding the need to create one manually via ListManagedNotificationChildEventsRequest.builder()

        Parameters:
        listManagedNotificationChildEventsRequest - A Consumer that will call methods on ListManagedNotificationChildEventsRequest.Builder to create a request.
        Returns:
        A custom publisher that can be subscribed to request a stream of response pages.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listManagedNotificationConfigurations

        default CompletableFuture<ListManagedNotificationConfigurationsResponse> listManagedNotificationConfigurations​(ListManagedNotificationConfigurationsRequest listManagedNotificationConfigurationsRequest)

        Returns a list of Managed Notification Configurations according to specified filters, ordered by creation time in reverse chronological order (newest first).

        Parameters:
        listManagedNotificationConfigurationsRequest -
        Returns:
        A Java Future containing the result of the ListManagedNotificationConfigurations operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listManagedNotificationConfigurations

        default CompletableFuture<ListManagedNotificationConfigurationsResponse> listManagedNotificationConfigurations​(Consumer<ListManagedNotificationConfigurationsRequest.Builder> listManagedNotificationConfigurationsRequest)

        Returns a list of Managed Notification Configurations according to specified filters, ordered by creation time in reverse chronological order (newest first).


        This is a convenience which creates an instance of the ListManagedNotificationConfigurationsRequest.Builder avoiding the need to create one manually via ListManagedNotificationConfigurationsRequest.builder()

        Parameters:
        listManagedNotificationConfigurationsRequest - A Consumer that will call methods on ListManagedNotificationConfigurationsRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListManagedNotificationConfigurations operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listManagedNotificationConfigurationsPaginator

        default ListManagedNotificationConfigurationsPublisher listManagedNotificationConfigurationsPaginator​(ListManagedNotificationConfigurationsRequest listManagedNotificationConfigurationsRequest)

        This is a variant of listManagedNotificationConfigurations(software.amazon.awssdk.services.notifications.model.ListManagedNotificationConfigurationsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

        When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

        The following are few ways to use the response class:

        1) Using the subscribe helper method 
         
 software.amazon.awssdk.services.notifications.paginators.ListManagedNotificationConfigurationsPublisher publisher = client.listManagedNotificationConfigurationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.notifications.paginators.ListManagedNotificationConfigurationsPublisher publisher = client.listManagedNotificationConfigurationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.notifications.model.ListManagedNotificationConfigurationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.notifications.model.ListManagedNotificationConfigurationsResponse response) { //... };
 });
        As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

        Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

        Note: If you prefer to have control on service calls, use the listManagedNotificationConfigurations(software.amazon.awssdk.services.notifications.model.ListManagedNotificationConfigurationsRequest) operation.

        Parameters:
        listManagedNotificationConfigurationsRequest -
        Returns:
        A custom publisher that can be subscribed to request a stream of response pages.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listManagedNotificationConfigurationsPaginator

        default ListManagedNotificationConfigurationsPublisher listManagedNotificationConfigurationsPaginator​(Consumer<ListManagedNotificationConfigurationsRequest.Builder> listManagedNotificationConfigurationsRequest)

        This is a variant of listManagedNotificationConfigurations(software.amazon.awssdk.services.notifications.model.ListManagedNotificationConfigurationsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

        When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

        The following are few ways to use the response class:

        1) Using the subscribe helper method 
         
 software.amazon.awssdk.services.notifications.paginators.ListManagedNotificationConfigurationsPublisher publisher = client.listManagedNotificationConfigurationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.notifications.paginators.ListManagedNotificationConfigurationsPublisher publisher = client.listManagedNotificationConfigurationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.notifications.model.ListManagedNotificationConfigurationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.notifications.model.ListManagedNotificationConfigurationsResponse response) { //... };
 });
        As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

        Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

        Note: If you prefer to have control on service calls, use the listManagedNotificationConfigurations(software.amazon.awssdk.services.notifications.model.ListManagedNotificationConfigurationsRequest) operation.


        This is a convenience which creates an instance of the ListManagedNotificationConfigurationsRequest.Builder avoiding the need to create one manually via ListManagedNotificationConfigurationsRequest.builder()

        Parameters:
        listManagedNotificationConfigurationsRequest - A Consumer that will call methods on ListManagedNotificationConfigurationsRequest.Builder to create a request.
        Returns:
        A custom publisher that can be subscribed to request a stream of response pages.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listManagedNotificationEvents

        default CompletableFuture<ListManagedNotificationEventsResponse> listManagedNotificationEvents​(ListManagedNotificationEventsRequest listManagedNotificationEventsRequest)

        Returns a list of Managed Notification Events according to specified filters, ordered by creation time in reverse chronological order (newest first).

        Parameters:
        listManagedNotificationEventsRequest -
        Returns:
        A Java Future containing the result of the ListManagedNotificationEvents operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listManagedNotificationEvents

        default CompletableFuture<ListManagedNotificationEventsResponse> listManagedNotificationEvents​(Consumer<ListManagedNotificationEventsRequest.Builder> listManagedNotificationEventsRequest)

        Returns a list of Managed Notification Events according to specified filters, ordered by creation time in reverse chronological order (newest first).


        This is a convenience which creates an instance of the ListManagedNotificationEventsRequest.Builder avoiding the need to create one manually via ListManagedNotificationEventsRequest.builder()

        Parameters:
        listManagedNotificationEventsRequest - A Consumer that will call methods on ListManagedNotificationEventsRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListManagedNotificationEvents operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listManagedNotificationEventsPaginator

        default ListManagedNotificationEventsPublisher listManagedNotificationEventsPaginator​(ListManagedNotificationEventsRequest listManagedNotificationEventsRequest)

        This is a variant of listManagedNotificationEvents(software.amazon.awssdk.services.notifications.model.ListManagedNotificationEventsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

        When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

        The following are few ways to use the response class:

        1) Using the subscribe helper method 
         
 software.amazon.awssdk.services.notifications.paginators.ListManagedNotificationEventsPublisher publisher = client.listManagedNotificationEventsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.notifications.paginators.ListManagedNotificationEventsPublisher publisher = client.listManagedNotificationEventsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.notifications.model.ListManagedNotificationEventsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.notifications.model.ListManagedNotificationEventsResponse response) { //... };
 });
        As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

        Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

        Note: If you prefer to have control on service calls, use the listManagedNotificationEvents(software.amazon.awssdk.services.notifications.model.ListManagedNotificationEventsRequest) operation.

        Parameters:
        listManagedNotificationEventsRequest -
        Returns:
        A custom publisher that can be subscribed to request a stream of response pages.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listManagedNotificationEventsPaginator

        default ListManagedNotificationEventsPublisher listManagedNotificationEventsPaginator​(Consumer<ListManagedNotificationEventsRequest.Builder> listManagedNotificationEventsRequest)

        This is a variant of listManagedNotificationEvents(software.amazon.awssdk.services.notifications.model.ListManagedNotificationEventsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

        When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

        The following are few ways to use the response class:

        1) Using the subscribe helper method 
         
 software.amazon.awssdk.services.notifications.paginators.ListManagedNotificationEventsPublisher publisher = client.listManagedNotificationEventsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.notifications.paginators.ListManagedNotificationEventsPublisher publisher = client.listManagedNotificationEventsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.notifications.model.ListManagedNotificationEventsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.notifications.model.ListManagedNotificationEventsResponse response) { //... };
 });
        As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

        Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

        Note: If you prefer to have control on service calls, use the listManagedNotificationEvents(software.amazon.awssdk.services.notifications.model.ListManagedNotificationEventsRequest) operation.


        This is a convenience which creates an instance of the ListManagedNotificationEventsRequest.Builder avoiding the need to create one manually via ListManagedNotificationEventsRequest.builder()

        Parameters:
        listManagedNotificationEventsRequest - A Consumer that will call methods on ListManagedNotificationEventsRequest.Builder to create a request.
        Returns:
        A custom publisher that can be subscribed to request a stream of response pages.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listNotificationConfigurations

        default CompletableFuture<ListNotificationConfigurationsResponse> listNotificationConfigurations​(ListNotificationConfigurationsRequest listNotificationConfigurationsRequest)

        Returns a list of abbreviated NotificationConfigurations according to specified filters, in reverse chronological order (newest first).

        Parameters:
        listNotificationConfigurationsRequest -
        Returns:
        A Java Future containing the result of the ListNotificationConfigurations operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listNotificationConfigurations

        default CompletableFuture<ListNotificationConfigurationsResponse> listNotificationConfigurations​(Consumer<ListNotificationConfigurationsRequest.Builder> listNotificationConfigurationsRequest)

        Returns a list of abbreviated NotificationConfigurations according to specified filters, in reverse chronological order (newest first).


        This is a convenience which creates an instance of the ListNotificationConfigurationsRequest.Builder avoiding the need to create one manually via ListNotificationConfigurationsRequest.builder()

        Parameters:
        listNotificationConfigurationsRequest - A Consumer that will call methods on ListNotificationConfigurationsRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListNotificationConfigurations operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listNotificationConfigurationsPaginator

        default ListNotificationConfigurationsPublisher listNotificationConfigurationsPaginator​(ListNotificationConfigurationsRequest listNotificationConfigurationsRequest)

        This is a variant of listNotificationConfigurations(software.amazon.awssdk.services.notifications.model.ListNotificationConfigurationsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

        When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

        The following are few ways to use the response class:

        1) Using the subscribe helper method 
         
 software.amazon.awssdk.services.notifications.paginators.ListNotificationConfigurationsPublisher publisher = client.listNotificationConfigurationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.notifications.paginators.ListNotificationConfigurationsPublisher publisher = client.listNotificationConfigurationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.notifications.model.ListNotificationConfigurationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.notifications.model.ListNotificationConfigurationsResponse response) { //... };
 });
        As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

        Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

        Note: If you prefer to have control on service calls, use the listNotificationConfigurations(software.amazon.awssdk.services.notifications.model.ListNotificationConfigurationsRequest) operation.

        Parameters:
        listNotificationConfigurationsRequest -
        Returns:
        A custom publisher that can be subscribed to request a stream of response pages.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listNotificationConfigurationsPaginator

        default ListNotificationConfigurationsPublisher listNotificationConfigurationsPaginator​(Consumer<ListNotificationConfigurationsRequest.Builder> listNotificationConfigurationsRequest)

        This is a variant of listNotificationConfigurations(software.amazon.awssdk.services.notifications.model.ListNotificationConfigurationsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

        When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

        The following are few ways to use the response class:

        1) Using the subscribe helper method 
         
 software.amazon.awssdk.services.notifications.paginators.ListNotificationConfigurationsPublisher publisher = client.listNotificationConfigurationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.notifications.paginators.ListNotificationConfigurationsPublisher publisher = client.listNotificationConfigurationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.notifications.model.ListNotificationConfigurationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.notifications.model.ListNotificationConfigurationsResponse response) { //... };
 });
        As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

        Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

        Note: If you prefer to have control on service calls, use the listNotificationConfigurations(software.amazon.awssdk.services.notifications.model.ListNotificationConfigurationsRequest) operation.


        This is a convenience which creates an instance of the ListNotificationConfigurationsRequest.Builder avoiding the need to create one manually via ListNotificationConfigurationsRequest.builder()

        Parameters:
        listNotificationConfigurationsRequest - A Consumer that will call methods on ListNotificationConfigurationsRequest.Builder to create a request.
        Returns:
        A custom publisher that can be subscribed to request a stream of response pages.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listNotificationEvents

        default CompletableFuture<ListNotificationEventsResponse> listNotificationEvents​(ListNotificationEventsRequest listNotificationEventsRequest)

        Returns a list of NotificationEvents according to specified filters, in reverse chronological order (newest first).

        User Notifications stores notifications in the individual Regions you register as notification hubs and the Region of the source event rule. ListNotificationEvents only returns notifications stored in the same Region in which the action is called. User Notifications doesn't backfill notifications to new Regions selected as notification hubs. For this reason, we recommend that you make calls in your oldest registered notification hub. For more information, see Notification hubs in the Amazon Web Services User Notifications User Guide.

        Parameters:
        listNotificationEventsRequest -
        Returns:
        A Java Future containing the result of the ListNotificationEvents operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listNotificationEvents

        default CompletableFuture<ListNotificationEventsResponse> listNotificationEvents​(Consumer<ListNotificationEventsRequest.Builder> listNotificationEventsRequest)

        Returns a list of NotificationEvents according to specified filters, in reverse chronological order (newest first).

        User Notifications stores notifications in the individual Regions you register as notification hubs and the Region of the source event rule. ListNotificationEvents only returns notifications stored in the same Region in which the action is called. User Notifications doesn't backfill notifications to new Regions selected as notification hubs. For this reason, we recommend that you make calls in your oldest registered notification hub. For more information, see Notification hubs in the Amazon Web Services User Notifications User Guide.


        This is a convenience which creates an instance of the ListNotificationEventsRequest.Builder avoiding the need to create one manually via ListNotificationEventsRequest.builder()

        Parameters:
        listNotificationEventsRequest - A Consumer that will call methods on ListNotificationEventsRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListNotificationEvents operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listNotificationEventsPaginator

        default ListNotificationEventsPublisher listNotificationEventsPaginator​(ListNotificationEventsRequest listNotificationEventsRequest)

        This is a variant of listNotificationEvents(software.amazon.awssdk.services.notifications.model.ListNotificationEventsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

        When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

        The following are few ways to use the response class:

        1) Using the subscribe helper method 
         
 software.amazon.awssdk.services.notifications.paginators.ListNotificationEventsPublisher publisher = client.listNotificationEventsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.notifications.paginators.ListNotificationEventsPublisher publisher = client.listNotificationEventsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.notifications.model.ListNotificationEventsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.notifications.model.ListNotificationEventsResponse response) { //... };
 });
        As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

        Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

        Note: If you prefer to have control on service calls, use the listNotificationEvents(software.amazon.awssdk.services.notifications.model.ListNotificationEventsRequest) operation.

        Parameters:
        listNotificationEventsRequest -
        Returns:
        A custom publisher that can be subscribed to request a stream of response pages.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listNotificationEventsPaginator

        default ListNotificationEventsPublisher listNotificationEventsPaginator​(Consumer<ListNotificationEventsRequest.Builder> listNotificationEventsRequest)

        This is a variant of listNotificationEvents(software.amazon.awssdk.services.notifications.model.ListNotificationEventsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

        When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

        The following are few ways to use the response class:

        1) Using the subscribe helper method 
         
 software.amazon.awssdk.services.notifications.paginators.ListNotificationEventsPublisher publisher = client.listNotificationEventsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.notifications.paginators.ListNotificationEventsPublisher publisher = client.listNotificationEventsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.notifications.model.ListNotificationEventsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.notifications.model.ListNotificationEventsResponse response) { //... };
 });
        As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

        Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

        Note: If you prefer to have control on service calls, use the listNotificationEvents(software.amazon.awssdk.services.notifications.model.ListNotificationEventsRequest) operation.


        This is a convenience which creates an instance of the ListNotificationEventsRequest.Builder avoiding the need to create one manually via ListNotificationEventsRequest.builder()

        Parameters:
        listNotificationEventsRequest - A Consumer that will call methods on ListNotificationEventsRequest.Builder to create a request.
        Returns:
        A custom publisher that can be subscribed to request a stream of response pages.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listNotificationHubs

        default CompletableFuture<ListNotificationHubsResponse> listNotificationHubs​(ListNotificationHubsRequest listNotificationHubsRequest)

        Returns a list of NotificationHubs.

        Parameters:
        listNotificationHubsRequest -
        Returns:
        A Java Future containing the result of the ListNotificationHubs operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listNotificationHubs

        default CompletableFuture<ListNotificationHubsResponse> listNotificationHubs​(Consumer<ListNotificationHubsRequest.Builder> listNotificationHubsRequest)

        Returns a list of NotificationHubs.


        This is a convenience which creates an instance of the ListNotificationHubsRequest.Builder avoiding the need to create one manually via ListNotificationHubsRequest.builder()

        Parameters:
        listNotificationHubsRequest - A Consumer that will call methods on ListNotificationHubsRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListNotificationHubs operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listNotificationHubsPaginator

        default ListNotificationHubsPublisher listNotificationHubsPaginator​(ListNotificationHubsRequest listNotificationHubsRequest)

        This is a variant of listNotificationHubs(software.amazon.awssdk.services.notifications.model.ListNotificationHubsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

        When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

        The following are few ways to use the response class:

        1) Using the subscribe helper method 
         
 software.amazon.awssdk.services.notifications.paginators.ListNotificationHubsPublisher publisher = client.listNotificationHubsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.notifications.paginators.ListNotificationHubsPublisher publisher = client.listNotificationHubsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.notifications.model.ListNotificationHubsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.notifications.model.ListNotificationHubsResponse response) { //... };
 });
        As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

        Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

        Note: If you prefer to have control on service calls, use the listNotificationHubs(software.amazon.awssdk.services.notifications.model.ListNotificationHubsRequest) operation.

        Parameters:
        listNotificationHubsRequest -
        Returns:
        A custom publisher that can be subscribed to request a stream of response pages.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listNotificationHubsPaginator

        default ListNotificationHubsPublisher listNotificationHubsPaginator​(Consumer<ListNotificationHubsRequest.Builder> listNotificationHubsRequest)

        This is a variant of listNotificationHubs(software.amazon.awssdk.services.notifications.model.ListNotificationHubsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

        When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

        The following are few ways to use the response class:

        1) Using the subscribe helper method 
         
 software.amazon.awssdk.services.notifications.paginators.ListNotificationHubsPublisher publisher = client.listNotificationHubsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
        2) Using a custom subscriber 
         
 software.amazon.awssdk.services.notifications.paginators.ListNotificationHubsPublisher publisher = client.listNotificationHubsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.notifications.model.ListNotificationHubsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.notifications.model.ListNotificationHubsResponse response) { //... };
 });
        As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

        Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

        Note: If you prefer to have control on service calls, use the listNotificationHubs(software.amazon.awssdk.services.notifications.model.ListNotificationHubsRequest) operation.


        This is a convenience which creates an instance of the ListNotificationHubsRequest.Builder avoiding the need to create one manually via ListNotificationHubsRequest.builder()

        Parameters:
        listNotificationHubsRequest - A Consumer that will call methods on ListNotificationHubsRequest.Builder to create a request.
        Returns:
        A custom publisher that can be subscribed to request a stream of response pages.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listTagsForResource

        default CompletableFuture<ListTagsForResourceResponse> listTagsForResource​(ListTagsForResourceRequest listTagsForResourceRequest)

        Returns a list of tags for a specified Amazon Resource Name (ARN).

        For more information, see Tagging your Amazon Web Services resources in the Tagging Amazon Web Services Resources User Guide.

        This is only supported for NotificationConfigurations.

        Parameters:
        listTagsForResourceRequest -
        Returns:
        A Java Future containing the result of the ListTagsForResource operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • listTagsForResource

        default CompletableFuture<ListTagsForResourceResponse> listTagsForResource​(Consumer<ListTagsForResourceRequest.Builder> listTagsForResourceRequest)

        Returns a list of tags for a specified Amazon Resource Name (ARN).

        For more information, see Tagging your Amazon Web Services resources in the Tagging Amazon Web Services Resources User Guide.

        This is only supported for NotificationConfigurations.


        This is a convenience which creates an instance of the ListTagsForResourceRequest.Builder avoiding the need to create one manually via ListTagsForResourceRequest.builder()

        Parameters:
        listTagsForResourceRequest - A Consumer that will call methods on ListTagsForResourceRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the ListTagsForResource operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • registerNotificationHub

        default CompletableFuture<RegisterNotificationHubResponse> registerNotificationHub​(RegisterNotificationHubRequest registerNotificationHubRequest)

        Registers a NotificationConfiguration in the specified Region.

        There is a maximum of one NotificationConfiguration per Region. You can have a maximum of 3 NotificationHub resources at a time.

        Parameters:
        registerNotificationHubRequest -
        Returns:
        A Java Future containing the result of the RegisterNotificationHub operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceQuotaExceededException Request would cause a service quota to be exceeded.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • registerNotificationHub

        default CompletableFuture<RegisterNotificationHubResponse> registerNotificationHub​(Consumer<RegisterNotificationHubRequest.Builder> registerNotificationHubRequest)

        Registers a NotificationConfiguration in the specified Region.

        There is a maximum of one NotificationConfiguration per Region. You can have a maximum of 3 NotificationHub resources at a time.


        This is a convenience which creates an instance of the RegisterNotificationHubRequest.Builder avoiding the need to create one manually via RegisterNotificationHubRequest.builder()

        Parameters:
        registerNotificationHubRequest - A Consumer that will call methods on RegisterNotificationHubRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the RegisterNotificationHub operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • ServiceQuotaExceededException Request would cause a service quota to be exceeded.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • tagResource

        default CompletableFuture<TagResourceResponse> tagResource​(TagResourceRequest tagResourceRequest)

        Tags the resource with a tag key and value.

        For more information, see Tagging your Amazon Web Services resources in the Tagging Amazon Web Services Resources User Guide.

        This is only supported for NotificationConfigurations.

        Parameters:
        tagResourceRequest -
        Returns:
        A Java Future containing the result of the TagResource operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • tagResource

        default CompletableFuture<TagResourceResponse> tagResource​(Consumer<TagResourceRequest.Builder> tagResourceRequest)

        Tags the resource with a tag key and value.

        For more information, see Tagging your Amazon Web Services resources in the Tagging Amazon Web Services Resources User Guide.

        This is only supported for NotificationConfigurations.


        This is a convenience which creates an instance of the TagResourceRequest.Builder avoiding the need to create one manually via TagResourceRequest.builder()

        Parameters:
        tagResourceRequest - A Consumer that will call methods on TagResourceRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the TagResource operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • untagResource

        default CompletableFuture<UntagResourceResponse> untagResource​(UntagResourceRequest untagResourceRequest)

        Untags a resource with a specified Amazon Resource Name (ARN).

        For more information, see Tagging your Amazon Web Services resources in the Tagging Amazon Web Services Resources User Guide.

        Parameters:
        untagResourceRequest -
        Returns:
        A Java Future containing the result of the UntagResource operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • untagResource

        default CompletableFuture<UntagResourceResponse> untagResource​(Consumer<UntagResourceRequest.Builder> untagResourceRequest)

        Untags a resource with a specified Amazon Resource Name (ARN).

        For more information, see Tagging your Amazon Web Services resources in the Tagging Amazon Web Services Resources User Guide.


        This is a convenience which creates an instance of the UntagResourceRequest.Builder avoiding the need to create one manually via UntagResourceRequest.builder()

        Parameters:
        untagResourceRequest - A Consumer that will call methods on UntagResourceRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the UntagResource operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateEventRule

        default CompletableFuture<UpdateEventRuleResponse> updateEventRule​(UpdateEventRuleRequest updateEventRuleRequest)

        Updates an existing EventRule.

        Parameters:
        updateEventRuleRequest -
        Returns:
        A Java Future containing the result of the UpdateEventRule operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateEventRule

        default CompletableFuture<UpdateEventRuleResponse> updateEventRule​(Consumer<UpdateEventRuleRequest.Builder> updateEventRuleRequest)

        Updates an existing EventRule.


        This is a convenience which creates an instance of the UpdateEventRuleRequest.Builder avoiding the need to create one manually via UpdateEventRuleRequest.builder()

        Parameters:
        updateEventRuleRequest - A Consumer that will call methods on UpdateEventRuleRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the UpdateEventRule operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateNotificationConfiguration

        default CompletableFuture<UpdateNotificationConfigurationResponse> updateNotificationConfiguration​(UpdateNotificationConfigurationRequest updateNotificationConfigurationRequest)

        Updates a NotificationConfiguration.

        Parameters:
        updateNotificationConfigurationRequest -
        Returns:
        A Java Future containing the result of the UpdateNotificationConfiguration operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation

      • updateNotificationConfiguration

        default CompletableFuture<UpdateNotificationConfigurationResponse> updateNotificationConfiguration​(Consumer<UpdateNotificationConfigurationRequest.Builder> updateNotificationConfigurationRequest)

        Updates a NotificationConfiguration.


        This is a convenience which creates an instance of the UpdateNotificationConfigurationRequest.Builder avoiding the need to create one manually via UpdateNotificationConfigurationRequest.builder()

        Parameters:
        updateNotificationConfigurationRequest - A Consumer that will call methods on UpdateNotificationConfigurationRequest.Builder to create a request.
        Returns:
        A Java Future containing the result of the UpdateNotificationConfiguration operation returned by the service.
        The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
        • AccessDeniedException User does not have sufficient access to perform this action.
        • ValidationException This exception is thrown when the notification event fails validation.
        • InternalServerException Unexpected error during processing of request.
        • ThrottlingException Request was denied due to request throttling.
        • ConflictException Updating or deleting a resource can cause an inconsistent state.
        • ResourceNotFoundException Request references a resource which does not exist.
        • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
        • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
        • NotificationsException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
        See Also:
        AWS API Documentation