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 User Notifications API Reference provides descriptions, API request parameters, and the JSON response for each of the User Notifications 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).

For information about descriptions, API request parameters, and the JSON response for email contact related API actions, see the User Notifications Contacts API Reference Guide.

  • Field Details

  • Method Details

    • associateChannel

      default CompletableFuture<AssociateChannelResponse> associateChannel(AssociateChannelRequest associateChannelRequest)

      Associates a delivery Channel with a particular NotificationConfiguration. Supported Channels include Amazon Q Developer in chat applications, 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • associateChannel

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

      Associates a delivery Channel with a particular NotificationConfiguration. Supported Channels include Amazon Q Developer in chat applications, 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • associateManagedNotificationAdditionalChannel

      default CompletableFuture<AssociateManagedNotificationAdditionalChannelResponse> associateManagedNotificationAdditionalChannel(AssociateManagedNotificationAdditionalChannelRequest associateManagedNotificationAdditionalChannelRequest)

      Associates an additional Channel with a particular ManagedNotificationConfiguration.

      Supported Channels include Amazon Q Developer in chat applications, 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • associateManagedNotificationAdditionalChannel

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

      Associates an additional Channel with a particular ManagedNotificationConfiguration.

      Supported Channels include Amazon Q Developer in chat applications, 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • associateOrganizationalUnit

      default CompletableFuture<AssociateOrganizationalUnitResponse> associateOrganizationalUnit(AssociateOrganizationalUnitRequest associateOrganizationalUnitRequest)

      Associates an organizational unit with a notification configuration.

      Parameters:
      associateOrganizationalUnitRequest -
      Returns:
      A Java Future containing the result of the AssociateOrganizationalUnit 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • associateOrganizationalUnit

      default CompletableFuture<AssociateOrganizationalUnitResponse> associateOrganizationalUnit(Consumer<AssociateOrganizationalUnitRequest.Builder> associateOrganizationalUnitRequest)

      Associates an organizational unit with a notification configuration.


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

      Parameters:
      associateOrganizationalUnitRequest - A Consumer that will call methods on AssociateOrganizationalUnitRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the AssociateOrganizationalUnit 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • 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:

    • 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • 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:

    • 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • disassociateChannel

      default CompletableFuture<DisassociateChannelResponse> disassociateChannel(DisassociateChannelRequest disassociateChannelRequest)

      Disassociates a Channel from a specified NotificationConfiguration. Supported Channels include Amazon Q Developer in chat applications, 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • disassociateChannel

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

      Disassociates a Channel from a specified NotificationConfiguration. Supported Channels include Amazon Q Developer in chat applications, 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • disassociateManagedNotificationAdditionalChannel

      default CompletableFuture<DisassociateManagedNotificationAdditionalChannelResponse> disassociateManagedNotificationAdditionalChannel(DisassociateManagedNotificationAdditionalChannelRequest disassociateManagedNotificationAdditionalChannelRequest)

      Disassociates an additional Channel from a particular ManagedNotificationConfiguration.

      Supported Channels include Amazon Q Developer in chat applications, 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • disassociateManagedNotificationAdditionalChannel

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

      Disassociates an additional Channel from a particular ManagedNotificationConfiguration.

      Supported Channels include Amazon Q Developer in chat applications, 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • disassociateOrganizationalUnit

      default CompletableFuture<DisassociateOrganizationalUnitResponse> disassociateOrganizationalUnit(DisassociateOrganizationalUnitRequest disassociateOrganizationalUnitRequest)

      Removes the association between an organizational unit and a notification configuration.

      Parameters:
      disassociateOrganizationalUnitRequest -
      Returns:
      A Java Future containing the result of the DisassociateOrganizationalUnit 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • disassociateOrganizationalUnit

      default CompletableFuture<DisassociateOrganizationalUnitResponse> disassociateOrganizationalUnit(Consumer<DisassociateOrganizationalUnitRequest.Builder> disassociateOrganizationalUnitRequest)

      Removes the association between an organizational unit and a notification configuration.


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

      Parameters:
      disassociateOrganizationalUnitRequest - A Consumer that will call methods on DisassociateOrganizationalUnitRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DisassociateOrganizationalUnit 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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:

    • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • listMemberAccounts

      default CompletableFuture<ListMemberAccountsResponse> listMemberAccounts(ListMemberAccountsRequest listMemberAccountsRequest)

      Returns a list of member accounts associated with a notification configuration.

      Parameters:
      listMemberAccountsRequest -
      Returns:
      A Java Future containing the result of the ListMemberAccounts 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:

    • listMemberAccounts

      default CompletableFuture<ListMemberAccountsResponse> listMemberAccounts(Consumer<ListMemberAccountsRequest.Builder> listMemberAccountsRequest)

      Returns a list of member accounts associated with a notification configuration.


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

      Parameters:
      listMemberAccountsRequest - A Consumer that will call methods on ListMemberAccountsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListMemberAccounts 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:

    • listMemberAccountsPaginator

      default ListMemberAccountsPublisher listMemberAccountsPaginator(ListMemberAccountsRequest listMemberAccountsRequest)

      This is a variant of listMemberAccounts(software.amazon.awssdk.services.notifications.model.ListMemberAccountsRequest) 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.ListMemberAccountsPublisher publisher = client.listMemberAccountsPaginator(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.ListMemberAccountsPublisher publisher = client.listMemberAccountsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.notifications.model.ListMemberAccountsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.notifications.model.ListMemberAccountsResponse 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 listMemberAccounts(software.amazon.awssdk.services.notifications.model.ListMemberAccountsRequest) operation.

      Parameters:
      listMemberAccountsRequest -
      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:

    • listMemberAccountsPaginator

      default ListMemberAccountsPublisher listMemberAccountsPaginator(Consumer<ListMemberAccountsRequest.Builder> listMemberAccountsRequest)

      This is a variant of listMemberAccounts(software.amazon.awssdk.services.notifications.model.ListMemberAccountsRequest) 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.ListMemberAccountsPublisher publisher = client.listMemberAccountsPaginator(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.ListMemberAccountsPublisher publisher = client.listMemberAccountsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.notifications.model.ListMemberAccountsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.notifications.model.ListMemberAccountsResponse 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 listMemberAccounts(software.amazon.awssdk.services.notifications.model.ListMemberAccountsRequest) operation.


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

      Parameters:
      listMemberAccountsRequest - A Consumer that will call methods on ListMemberAccountsRequest.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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • listOrganizationalUnits

      default CompletableFuture<ListOrganizationalUnitsResponse> listOrganizationalUnits(ListOrganizationalUnitsRequest listOrganizationalUnitsRequest)

      Returns a list of organizational units associated with a notification configuration.

      Parameters:
      listOrganizationalUnitsRequest -
      Returns:
      A Java Future containing the result of the ListOrganizationalUnits 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • listOrganizationalUnits

      default CompletableFuture<ListOrganizationalUnitsResponse> listOrganizationalUnits(Consumer<ListOrganizationalUnitsRequest.Builder> listOrganizationalUnitsRequest)

      Returns a list of organizational units associated with a notification configuration.


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

      Parameters:
      listOrganizationalUnitsRequest - A Consumer that will call methods on ListOrganizationalUnitsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListOrganizationalUnits 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • listOrganizationalUnitsPaginator

      default ListOrganizationalUnitsPublisher listOrganizationalUnitsPaginator(ListOrganizationalUnitsRequest listOrganizationalUnitsRequest)

      This is a variant of listOrganizationalUnits(software.amazon.awssdk.services.notifications.model.ListOrganizationalUnitsRequest) 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.ListOrganizationalUnitsPublisher publisher = client.listOrganizationalUnitsPaginator(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.ListOrganizationalUnitsPublisher publisher = client.listOrganizationalUnitsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.notifications.model.ListOrganizationalUnitsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.notifications.model.ListOrganizationalUnitsResponse 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 listOrganizationalUnits(software.amazon.awssdk.services.notifications.model.ListOrganizationalUnitsRequest) operation.

      Parameters:
      listOrganizationalUnitsRequest -
      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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • listOrganizationalUnitsPaginator

      default ListOrganizationalUnitsPublisher listOrganizationalUnitsPaginator(Consumer<ListOrganizationalUnitsRequest.Builder> listOrganizationalUnitsRequest)

      This is a variant of listOrganizationalUnits(software.amazon.awssdk.services.notifications.model.ListOrganizationalUnitsRequest) 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.ListOrganizationalUnitsPublisher publisher = client.listOrganizationalUnitsPaginator(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.ListOrganizationalUnitsPublisher publisher = client.listOrganizationalUnitsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.notifications.model.ListOrganizationalUnitsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.notifications.model.ListOrganizationalUnitsResponse 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 listOrganizationalUnits(software.amazon.awssdk.services.notifications.model.ListOrganizationalUnitsRequest) operation.


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

      Parameters:
      listOrganizationalUnitsRequest - A Consumer that will call methods on ListOrganizationalUnitsRequest.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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • 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:

    • 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • 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.
      • ConflictException Updating or deleting a resource can cause an inconsistent state.
      • ResourceNotFoundException Request references a resource which does not exist.
      • 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:

    • serviceClientConfiguration

      default NotificationsServiceClientConfiguration serviceClientConfiguration()
      Description copied from interface: SdkClient
      The SDK service client configuration exposes client settings to the user, e.g., ClientOverrideConfiguration
      Specified by:
      serviceClientConfiguration in interface AwsClient
      Specified by:
      serviceClientConfiguration in interface SdkClient
      Returns:
      SdkServiceClientConfiguration

    • create

      static NotificationsAsyncClient create()
      Create a NotificationsAsyncClient with the region loaded from the DefaultAwsRegionProviderChain and credentials loaded from the DefaultCredentialsProvider.

    • builder

      static NotificationsAsyncClientBuilder builder()
      Create a builder that can be used to configure and create a NotificationsAsyncClient.