Interface RedshiftServerlessAsyncClient

All Superinterfaces:
AutoCloseable, AwsClient, SdkAutoCloseable, SdkClient
@Generated("software.amazon.awssdk:codegen") @SdkPublicApi @ThreadSafe public interface RedshiftServerlessAsyncClient extends AwsClient
Service client for accessing Redshift Serverless 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.

This is an interface reference for Amazon Redshift Serverless. It contains documentation for one of the programming or command line interfaces you can use to manage Amazon Redshift Serverless.

Amazon Redshift Serverless automatically provisions data warehouse capacity and intelligently scales the underlying resources based on workload demands. Amazon Redshift Serverless adjusts capacity in seconds to deliver consistently high performance and simplified operations for even the most demanding and volatile workloads. Amazon Redshift Serverless lets you focus on using your data to acquire new insights for your business and customers.

To learn more about Amazon Redshift Serverless, see What is Amazon Redshift Serverless?.

  • Field Details

  • Method Details

    • convertRecoveryPointToSnapshot

      default CompletableFuture<ConvertRecoveryPointToSnapshotResponse> convertRecoveryPointToSnapshot(ConvertRecoveryPointToSnapshotRequest convertRecoveryPointToSnapshotRequest)

      Converts a recovery point to a snapshot. For more information about recovery points and snapshots, see Working with snapshots and recovery points.

      Parameters:
      convertRecoveryPointToSnapshotRequest -
      Returns:
      A Java Future containing the result of the ConvertRecoveryPointToSnapshot 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • TooManyTagsException The request exceeded the number of tags allowed for a resource.
      • ServiceQuotaExceededException The service limit was exceeded.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • convertRecoveryPointToSnapshot

      default CompletableFuture<ConvertRecoveryPointToSnapshotResponse> convertRecoveryPointToSnapshot(Consumer<ConvertRecoveryPointToSnapshotRequest.Builder> convertRecoveryPointToSnapshotRequest)

      Converts a recovery point to a snapshot. For more information about recovery points and snapshots, see Working with snapshots and recovery points.


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

      Parameters:
      convertRecoveryPointToSnapshotRequest - A Consumer that will call methods on ConvertRecoveryPointToSnapshotRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ConvertRecoveryPointToSnapshot 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • TooManyTagsException The request exceeded the number of tags allowed for a resource.
      • ServiceQuotaExceededException The service limit was exceeded.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createCustomDomainAssociation

      default CompletableFuture<CreateCustomDomainAssociationResponse> createCustomDomainAssociation(CreateCustomDomainAssociationRequest createCustomDomainAssociationRequest)

      Creates a custom domain association for Amazon Redshift Serverless.

      Parameters:
      createCustomDomainAssociationRequest -
      Returns:
      A Java Future containing the result of the CreateCustomDomainAssociation 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createCustomDomainAssociation

      default CompletableFuture<CreateCustomDomainAssociationResponse> createCustomDomainAssociation(Consumer<CreateCustomDomainAssociationRequest.Builder> createCustomDomainAssociationRequest)

      Creates a custom domain association for Amazon Redshift Serverless.


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

      Parameters:
      createCustomDomainAssociationRequest - A Consumer that will call methods on CreateCustomDomainAssociationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateCustomDomainAssociation 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createEndpointAccess

      default CompletableFuture<CreateEndpointAccessResponse> createEndpointAccess(CreateEndpointAccessRequest createEndpointAccessRequest)

      Creates an Amazon Redshift Serverless managed VPC endpoint.

      Parameters:
      createEndpointAccessRequest -
      Returns:
      A Java Future containing the result of the CreateEndpointAccess 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ServiceQuotaExceededException The service limit was exceeded.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createEndpointAccess

      default CompletableFuture<CreateEndpointAccessResponse> createEndpointAccess(Consumer<CreateEndpointAccessRequest.Builder> createEndpointAccessRequest)

      Creates an Amazon Redshift Serverless managed VPC endpoint.


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

      Parameters:
      createEndpointAccessRequest - A Consumer that will call methods on CreateEndpointAccessRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateEndpointAccess 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ServiceQuotaExceededException The service limit was exceeded.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createNamespace

      default CompletableFuture<CreateNamespaceResponse> createNamespace(CreateNamespaceRequest createNamespaceRequest)

      Creates a namespace in Amazon Redshift Serverless.

      Parameters:
      createNamespaceRequest -
      Returns:
      A Java Future containing the result of the CreateNamespace 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • TooManyTagsException The request exceeded the number of tags allowed for a resource.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createNamespace

      default CompletableFuture<CreateNamespaceResponse> createNamespace(Consumer<CreateNamespaceRequest.Builder> createNamespaceRequest)

      Creates a namespace in Amazon Redshift Serverless.


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

      Parameters:
      createNamespaceRequest - A Consumer that will call methods on CreateNamespaceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateNamespace 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • TooManyTagsException The request exceeded the number of tags allowed for a resource.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createReservation

      default CompletableFuture<CreateReservationResponse> createReservation(CreateReservationRequest createReservationRequest)

      Creates an Amazon Redshift Serverless reservation, which gives you the option to commit to a specified number of Redshift Processing Units (RPUs) for a year at a discount from Serverless on-demand (OD) rates.

      Parameters:
      createReservationRequest -
      Returns:
      A Java Future containing the result of the CreateReservation 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • TooManyTagsException The request exceeded the number of tags allowed for a resource.
      • ServiceQuotaExceededException The service limit was exceeded.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createReservation

      default CompletableFuture<CreateReservationResponse> createReservation(Consumer<CreateReservationRequest.Builder> createReservationRequest)

      Creates an Amazon Redshift Serverless reservation, which gives you the option to commit to a specified number of Redshift Processing Units (RPUs) for a year at a discount from Serverless on-demand (OD) rates.


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

      Parameters:
      createReservationRequest - A Consumer that will call methods on CreateReservationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateReservation 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • TooManyTagsException The request exceeded the number of tags allowed for a resource.
      • ServiceQuotaExceededException The service limit was exceeded.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createScheduledAction

      default CompletableFuture<CreateScheduledActionResponse> createScheduledAction(CreateScheduledActionRequest createScheduledActionRequest)

      Creates a scheduled action. A scheduled action contains a schedule and an Amazon Redshift API action. For example, you can create a schedule of when to run the CreateSnapshot API operation.

      Parameters:
      createScheduledActionRequest -
      Returns:
      A Java Future containing the result of the CreateScheduledAction 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createScheduledAction

      default CompletableFuture<CreateScheduledActionResponse> createScheduledAction(Consumer<CreateScheduledActionRequest.Builder> createScheduledActionRequest)

      Creates a scheduled action. A scheduled action contains a schedule and an Amazon Redshift API action. For example, you can create a schedule of when to run the CreateSnapshot API operation.


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

      Parameters:
      createScheduledActionRequest - A Consumer that will call methods on CreateScheduledActionRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateScheduledAction 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createSnapshot

      default CompletableFuture<CreateSnapshotResponse> createSnapshot(CreateSnapshotRequest createSnapshotRequest)

      Creates a snapshot of all databases in a namespace. For more information about snapshots, see Working with snapshots and recovery points.

      Parameters:
      createSnapshotRequest -
      Returns:
      A Java Future containing the result of the CreateSnapshot 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • TooManyTagsException The request exceeded the number of tags allowed for a resource.
      • ServiceQuotaExceededException The service limit was exceeded.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createSnapshot

      default CompletableFuture<CreateSnapshotResponse> createSnapshot(Consumer<CreateSnapshotRequest.Builder> createSnapshotRequest)

      Creates a snapshot of all databases in a namespace. For more information about snapshots, see Working with snapshots and recovery points.


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

      Parameters:
      createSnapshotRequest - A Consumer that will call methods on CreateSnapshotRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateSnapshot 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • TooManyTagsException The request exceeded the number of tags allowed for a resource.
      • ServiceQuotaExceededException The service limit was exceeded.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createSnapshotCopyConfiguration

      default CompletableFuture<CreateSnapshotCopyConfigurationResponse> createSnapshotCopyConfiguration(CreateSnapshotCopyConfigurationRequest createSnapshotCopyConfigurationRequest)

      Creates a snapshot copy configuration that lets you copy snapshots to another Amazon Web Services Region.

      Parameters:
      createSnapshotCopyConfigurationRequest -
      Returns:
      A Java Future containing the result of the CreateSnapshotCopyConfiguration 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ServiceQuotaExceededException The service limit was exceeded.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createSnapshotCopyConfiguration

      default CompletableFuture<CreateSnapshotCopyConfigurationResponse> createSnapshotCopyConfiguration(Consumer<CreateSnapshotCopyConfigurationRequest.Builder> createSnapshotCopyConfigurationRequest)

      Creates a snapshot copy configuration that lets you copy snapshots to another Amazon Web Services Region.


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

      Parameters:
      createSnapshotCopyConfigurationRequest - A Consumer that will call methods on CreateSnapshotCopyConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateSnapshotCopyConfiguration 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ServiceQuotaExceededException The service limit was exceeded.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createUsageLimit

      default CompletableFuture<CreateUsageLimitResponse> createUsageLimit(CreateUsageLimitRequest createUsageLimitRequest)

      Creates a usage limit for a specified Amazon Redshift Serverless usage type. The usage limit is identified by the returned usage limit identifier.

      Parameters:
      createUsageLimitRequest -
      Returns:
      A Java Future containing the result of the CreateUsageLimit 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • ServiceQuotaExceededException The service limit was exceeded.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createUsageLimit

      default CompletableFuture<CreateUsageLimitResponse> createUsageLimit(Consumer<CreateUsageLimitRequest.Builder> createUsageLimitRequest)

      Creates a usage limit for a specified Amazon Redshift Serverless usage type. The usage limit is identified by the returned usage limit identifier.


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

      Parameters:
      createUsageLimitRequest - A Consumer that will call methods on CreateUsageLimitRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateUsageLimit 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • ServiceQuotaExceededException The service limit was exceeded.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createWorkgroup

      default CompletableFuture<CreateWorkgroupResponse> createWorkgroup(CreateWorkgroupRequest createWorkgroupRequest)

      Creates an workgroup in Amazon Redshift Serverless.

      VPC Block Public Access (BPA) enables you to block resources in VPCs and subnets that you own in a Region from reaching or being reached from the internet through internet gateways and egress-only internet gateways. If a workgroup is in an account with VPC BPA turned on, the following capabilities are blocked:

      • Creating a public access workgroup

      • Modifying a private workgroup to public

      • Adding a subnet with VPC BPA turned on to the workgroup when the workgroup is public

      For more information about VPC BPA, see Block public access to VPCs and subnets in the Amazon VPC User Guide.

      Parameters:
      createWorkgroupRequest -
      Returns:
      A Java Future containing the result of the CreateWorkgroup 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • InsufficientCapacityException There is an insufficient capacity to perform the action.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • TooManyTagsException The request exceeded the number of tags allowed for a resource.
      • Ipv6CidrBlockNotFoundException There are no subnets in your VPC with associated IPv6 CIDR blocks. To use dual-stack mode, associate an IPv6 CIDR block with each subnet in your VPC.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createWorkgroup

      default CompletableFuture<CreateWorkgroupResponse> createWorkgroup(Consumer<CreateWorkgroupRequest.Builder> createWorkgroupRequest)

      Creates an workgroup in Amazon Redshift Serverless.

      VPC Block Public Access (BPA) enables you to block resources in VPCs and subnets that you own in a Region from reaching or being reached from the internet through internet gateways and egress-only internet gateways. If a workgroup is in an account with VPC BPA turned on, the following capabilities are blocked:

      • Creating a public access workgroup

      • Modifying a private workgroup to public

      • Adding a subnet with VPC BPA turned on to the workgroup when the workgroup is public

      For more information about VPC BPA, see Block public access to VPCs and subnets in the Amazon VPC User Guide.


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

      Parameters:
      createWorkgroupRequest - A Consumer that will call methods on CreateWorkgroupRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateWorkgroup 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • InsufficientCapacityException There is an insufficient capacity to perform the action.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • TooManyTagsException The request exceeded the number of tags allowed for a resource.
      • Ipv6CidrBlockNotFoundException There are no subnets in your VPC with associated IPv6 CIDR blocks. To use dual-stack mode, associate an IPv6 CIDR block with each subnet in your VPC.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteCustomDomainAssociation

      default CompletableFuture<DeleteCustomDomainAssociationResponse> deleteCustomDomainAssociation(DeleteCustomDomainAssociationRequest deleteCustomDomainAssociationRequest)

      Deletes a custom domain association for Amazon Redshift Serverless.

      Parameters:
      deleteCustomDomainAssociationRequest -
      Returns:
      A Java Future containing the result of the DeleteCustomDomainAssociation 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteCustomDomainAssociation

      default CompletableFuture<DeleteCustomDomainAssociationResponse> deleteCustomDomainAssociation(Consumer<DeleteCustomDomainAssociationRequest.Builder> deleteCustomDomainAssociationRequest)

      Deletes a custom domain association for Amazon Redshift Serverless.


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

      Parameters:
      deleteCustomDomainAssociationRequest - A Consumer that will call methods on DeleteCustomDomainAssociationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteCustomDomainAssociation 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteEndpointAccess

      default CompletableFuture<DeleteEndpointAccessResponse> deleteEndpointAccess(DeleteEndpointAccessRequest deleteEndpointAccessRequest)

      Deletes an Amazon Redshift Serverless managed VPC endpoint.

      Parameters:
      deleteEndpointAccessRequest -
      Returns:
      A Java Future containing the result of the DeleteEndpointAccess 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteEndpointAccess

      default CompletableFuture<DeleteEndpointAccessResponse> deleteEndpointAccess(Consumer<DeleteEndpointAccessRequest.Builder> deleteEndpointAccessRequest)

      Deletes an Amazon Redshift Serverless managed VPC endpoint.


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

      Parameters:
      deleteEndpointAccessRequest - A Consumer that will call methods on DeleteEndpointAccessRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteEndpointAccess 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteNamespace

      default CompletableFuture<DeleteNamespaceResponse> deleteNamespace(DeleteNamespaceRequest deleteNamespaceRequest)

      Deletes a namespace from Amazon Redshift Serverless. Before you delete the namespace, you can create a final snapshot that has all of the data within the namespace.

      Parameters:
      deleteNamespaceRequest -
      Returns:
      A Java Future containing the result of the DeleteNamespace 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteNamespace

      default CompletableFuture<DeleteNamespaceResponse> deleteNamespace(Consumer<DeleteNamespaceRequest.Builder> deleteNamespaceRequest)

      Deletes a namespace from Amazon Redshift Serverless. Before you delete the namespace, you can create a final snapshot that has all of the data within the namespace.


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

      Parameters:
      deleteNamespaceRequest - A Consumer that will call methods on DeleteNamespaceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteNamespace 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteResourcePolicy

      default CompletableFuture<DeleteResourcePolicyResponse> deleteResourcePolicy(DeleteResourcePolicyRequest deleteResourcePolicyRequest)

      Deletes the specified resource policy.

      Parameters:
      deleteResourcePolicyRequest -
      Returns:
      A Java Future containing the result of the DeleteResourcePolicy 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteResourcePolicy

      default CompletableFuture<DeleteResourcePolicyResponse> deleteResourcePolicy(Consumer<DeleteResourcePolicyRequest.Builder> deleteResourcePolicyRequest)

      Deletes the specified resource policy.


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

      Parameters:
      deleteResourcePolicyRequest - A Consumer that will call methods on DeleteResourcePolicyRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteResourcePolicy 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteScheduledAction

      default CompletableFuture<DeleteScheduledActionResponse> deleteScheduledAction(DeleteScheduledActionRequest deleteScheduledActionRequest)

      Deletes a scheduled action.

      Parameters:
      deleteScheduledActionRequest -
      Returns:
      A Java Future containing the result of the DeleteScheduledAction 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteScheduledAction

      default CompletableFuture<DeleteScheduledActionResponse> deleteScheduledAction(Consumer<DeleteScheduledActionRequest.Builder> deleteScheduledActionRequest)

      Deletes a scheduled action.


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

      Parameters:
      deleteScheduledActionRequest - A Consumer that will call methods on DeleteScheduledActionRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteScheduledAction 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteSnapshot

      default CompletableFuture<DeleteSnapshotResponse> deleteSnapshot(DeleteSnapshotRequest deleteSnapshotRequest)

      Deletes a snapshot from Amazon Redshift Serverless.

      Parameters:
      deleteSnapshotRequest -
      Returns:
      A Java Future containing the result of the DeleteSnapshot 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteSnapshot

      default CompletableFuture<DeleteSnapshotResponse> deleteSnapshot(Consumer<DeleteSnapshotRequest.Builder> deleteSnapshotRequest)

      Deletes a snapshot from Amazon Redshift Serverless.


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

      Parameters:
      deleteSnapshotRequest - A Consumer that will call methods on DeleteSnapshotRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteSnapshot 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteSnapshotCopyConfiguration

      default CompletableFuture<DeleteSnapshotCopyConfigurationResponse> deleteSnapshotCopyConfiguration(DeleteSnapshotCopyConfigurationRequest deleteSnapshotCopyConfigurationRequest)

      Deletes a snapshot copy configuration

      Parameters:
      deleteSnapshotCopyConfigurationRequest -
      Returns:
      A Java Future containing the result of the DeleteSnapshotCopyConfiguration 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteSnapshotCopyConfiguration

      default CompletableFuture<DeleteSnapshotCopyConfigurationResponse> deleteSnapshotCopyConfiguration(Consumer<DeleteSnapshotCopyConfigurationRequest.Builder> deleteSnapshotCopyConfigurationRequest)

      Deletes a snapshot copy configuration


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

      Parameters:
      deleteSnapshotCopyConfigurationRequest - A Consumer that will call methods on DeleteSnapshotCopyConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteSnapshotCopyConfiguration 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteUsageLimit

      default CompletableFuture<DeleteUsageLimitResponse> deleteUsageLimit(DeleteUsageLimitRequest deleteUsageLimitRequest)

      Deletes a usage limit from Amazon Redshift Serverless.

      Parameters:
      deleteUsageLimitRequest -
      Returns:
      A Java Future containing the result of the DeleteUsageLimit 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteUsageLimit

      default CompletableFuture<DeleteUsageLimitResponse> deleteUsageLimit(Consumer<DeleteUsageLimitRequest.Builder> deleteUsageLimitRequest)

      Deletes a usage limit from Amazon Redshift Serverless.


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

      Parameters:
      deleteUsageLimitRequest - A Consumer that will call methods on DeleteUsageLimitRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteUsageLimit 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteWorkgroup

      default CompletableFuture<DeleteWorkgroupResponse> deleteWorkgroup(DeleteWorkgroupRequest deleteWorkgroupRequest)

      Deletes a workgroup.

      Parameters:
      deleteWorkgroupRequest -
      Returns:
      A Java Future containing the result of the DeleteWorkgroup 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteWorkgroup

      default CompletableFuture<DeleteWorkgroupResponse> deleteWorkgroup(Consumer<DeleteWorkgroupRequest.Builder> deleteWorkgroupRequest)

      Deletes a workgroup.


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

      Parameters:
      deleteWorkgroupRequest - A Consumer that will call methods on DeleteWorkgroupRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteWorkgroup 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getCredentials

      default CompletableFuture<GetCredentialsResponse> getCredentials(GetCredentialsRequest getCredentialsRequest)

      Returns a database user name and temporary password with temporary authorization to log in to Amazon Redshift Serverless.

      By default, the temporary credentials expire in 900 seconds. You can optionally specify a duration between 900 seconds (15 minutes) and 3600 seconds (60 minutes).

      The Identity and Access Management (IAM) user or role that runs GetCredentials must have an IAM policy attached that allows access to all necessary actions and resources.

      If the DbName parameter is specified, the IAM policy must allow access to the resource dbname for the specified database name.

      Parameters:
      getCredentialsRequest -
      Returns:
      A Java Future containing the result of the GetCredentials 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getCredentials

      default CompletableFuture<GetCredentialsResponse> getCredentials(Consumer<GetCredentialsRequest.Builder> getCredentialsRequest)

      Returns a database user name and temporary password with temporary authorization to log in to Amazon Redshift Serverless.

      By default, the temporary credentials expire in 900 seconds. You can optionally specify a duration between 900 seconds (15 minutes) and 3600 seconds (60 minutes).

      The Identity and Access Management (IAM) user or role that runs GetCredentials must have an IAM policy attached that allows access to all necessary actions and resources.

      If the DbName parameter is specified, the IAM policy must allow access to the resource dbname for the specified database name.


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

      Parameters:
      getCredentialsRequest - A Consumer that will call methods on GetCredentialsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetCredentials 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getCustomDomainAssociation

      default CompletableFuture<GetCustomDomainAssociationResponse> getCustomDomainAssociation(GetCustomDomainAssociationRequest getCustomDomainAssociationRequest)

      Gets information about a specific custom domain association.

      Parameters:
      getCustomDomainAssociationRequest -
      Returns:
      A Java Future containing the result of the GetCustomDomainAssociation 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getCustomDomainAssociation

      default CompletableFuture<GetCustomDomainAssociationResponse> getCustomDomainAssociation(Consumer<GetCustomDomainAssociationRequest.Builder> getCustomDomainAssociationRequest)

      Gets information about a specific custom domain association.


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

      Parameters:
      getCustomDomainAssociationRequest - A Consumer that will call methods on GetCustomDomainAssociationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetCustomDomainAssociation 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getEndpointAccess

      default CompletableFuture<GetEndpointAccessResponse> getEndpointAccess(GetEndpointAccessRequest getEndpointAccessRequest)

      Returns information, such as the name, about a VPC endpoint.

      Parameters:
      getEndpointAccessRequest -
      Returns:
      A Java Future containing the result of the GetEndpointAccess 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getEndpointAccess

      default CompletableFuture<GetEndpointAccessResponse> getEndpointAccess(Consumer<GetEndpointAccessRequest.Builder> getEndpointAccessRequest)

      Returns information, such as the name, about a VPC endpoint.


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

      Parameters:
      getEndpointAccessRequest - A Consumer that will call methods on GetEndpointAccessRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetEndpointAccess 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getNamespace

      default CompletableFuture<GetNamespaceResponse> getNamespace(GetNamespaceRequest getNamespaceRequest)

      Returns information about a namespace in Amazon Redshift Serverless.

      Parameters:
      getNamespaceRequest -
      Returns:
      A Java Future containing the result of the GetNamespace 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getNamespace

      default CompletableFuture<GetNamespaceResponse> getNamespace(Consumer<GetNamespaceRequest.Builder> getNamespaceRequest)

      Returns information about a namespace in Amazon Redshift Serverless.


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

      Parameters:
      getNamespaceRequest - A Consumer that will call methods on GetNamespaceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetNamespace 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getRecoveryPoint

      default CompletableFuture<GetRecoveryPointResponse> getRecoveryPoint(GetRecoveryPointRequest getRecoveryPointRequest)

      Returns information about a recovery point.

      Parameters:
      getRecoveryPointRequest -
      Returns:
      A Java Future containing the result of the GetRecoveryPoint 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getRecoveryPoint

      default CompletableFuture<GetRecoveryPointResponse> getRecoveryPoint(Consumer<GetRecoveryPointRequest.Builder> getRecoveryPointRequest)

      Returns information about a recovery point.


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

      Parameters:
      getRecoveryPointRequest - A Consumer that will call methods on GetRecoveryPointRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetRecoveryPoint 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getReservation

      default CompletableFuture<GetReservationResponse> getReservation(GetReservationRequest getReservationRequest)

      Gets an Amazon Redshift Serverless reservation. A reservation gives you the option to commit to a specified number of Redshift Processing Units (RPUs) for a year at a discount from Serverless on-demand (OD) rates.

      Parameters:
      getReservationRequest -
      Returns:
      A Java Future containing the result of the GetReservation 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getReservation

      default CompletableFuture<GetReservationResponse> getReservation(Consumer<GetReservationRequest.Builder> getReservationRequest)

      Gets an Amazon Redshift Serverless reservation. A reservation gives you the option to commit to a specified number of Redshift Processing Units (RPUs) for a year at a discount from Serverless on-demand (OD) rates.


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

      Parameters:
      getReservationRequest - A Consumer that will call methods on GetReservationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetReservation 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getReservationOffering

      default CompletableFuture<GetReservationOfferingResponse> getReservationOffering(GetReservationOfferingRequest getReservationOfferingRequest)

      Returns the reservation offering. The offering determines the payment schedule for the reservation.

      Parameters:
      getReservationOfferingRequest -
      Returns:
      A Java Future containing the result of the GetReservationOffering 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getReservationOffering

      default CompletableFuture<GetReservationOfferingResponse> getReservationOffering(Consumer<GetReservationOfferingRequest.Builder> getReservationOfferingRequest)

      Returns the reservation offering. The offering determines the payment schedule for the reservation.


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

      Parameters:
      getReservationOfferingRequest - A Consumer that will call methods on GetReservationOfferingRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetReservationOffering 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getResourcePolicy

      default CompletableFuture<GetResourcePolicyResponse> getResourcePolicy(GetResourcePolicyRequest getResourcePolicyRequest)

      Returns a resource policy.

      Parameters:
      getResourcePolicyRequest -
      Returns:
      A Java Future containing the result of the GetResourcePolicy 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getResourcePolicy

      default CompletableFuture<GetResourcePolicyResponse> getResourcePolicy(Consumer<GetResourcePolicyRequest.Builder> getResourcePolicyRequest)

      Returns a resource policy.


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

      Parameters:
      getResourcePolicyRequest - A Consumer that will call methods on GetResourcePolicyRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetResourcePolicy 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getScheduledAction

      default CompletableFuture<GetScheduledActionResponse> getScheduledAction(GetScheduledActionRequest getScheduledActionRequest)

      Returns information about a scheduled action.

      Parameters:
      getScheduledActionRequest -
      Returns:
      A Java Future containing the result of the GetScheduledAction 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getScheduledAction

      default CompletableFuture<GetScheduledActionResponse> getScheduledAction(Consumer<GetScheduledActionRequest.Builder> getScheduledActionRequest)

      Returns information about a scheduled action.


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

      Parameters:
      getScheduledActionRequest - A Consumer that will call methods on GetScheduledActionRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetScheduledAction 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getSnapshot

      default CompletableFuture<GetSnapshotResponse> getSnapshot(GetSnapshotRequest getSnapshotRequest)

      Returns information about a specific snapshot.

      Parameters:
      getSnapshotRequest -
      Returns:
      A Java Future containing the result of the GetSnapshot 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getSnapshot

      default CompletableFuture<GetSnapshotResponse> getSnapshot(Consumer<GetSnapshotRequest.Builder> getSnapshotRequest)

      Returns information about a specific snapshot.


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

      Parameters:
      getSnapshotRequest - A Consumer that will call methods on GetSnapshotRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetSnapshot 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getTableRestoreStatus

      default CompletableFuture<GetTableRestoreStatusResponse> getTableRestoreStatus(GetTableRestoreStatusRequest getTableRestoreStatusRequest)

      Returns information about a TableRestoreStatus object.

      Parameters:
      getTableRestoreStatusRequest -
      Returns:
      A Java Future containing the result of the GetTableRestoreStatus 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.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getTableRestoreStatus

      default CompletableFuture<GetTableRestoreStatusResponse> getTableRestoreStatus(Consumer<GetTableRestoreStatusRequest.Builder> getTableRestoreStatusRequest)

      Returns information about a TableRestoreStatus object.


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

      Parameters:
      getTableRestoreStatusRequest - A Consumer that will call methods on GetTableRestoreStatusRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetTableRestoreStatus 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.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getTrack

      default CompletableFuture<GetTrackResponse> getTrack(GetTrackRequest getTrackRequest)

      Get the Redshift Serverless version for a specified track.

      Parameters:
      getTrackRequest -
      Returns:
      A Java Future containing the result of the GetTrack 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getTrack

      default CompletableFuture<GetTrackResponse> getTrack(Consumer<GetTrackRequest.Builder> getTrackRequest)

      Get the Redshift Serverless version for a specified track.


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

      Parameters:
      getTrackRequest - A Consumer that will call methods on GetTrackRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetTrack 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getUsageLimit

      default CompletableFuture<GetUsageLimitResponse> getUsageLimit(GetUsageLimitRequest getUsageLimitRequest)

      Returns information about a usage limit.

      Parameters:
      getUsageLimitRequest -
      Returns:
      A Java Future containing the result of the GetUsageLimit 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getUsageLimit

      default CompletableFuture<GetUsageLimitResponse> getUsageLimit(Consumer<GetUsageLimitRequest.Builder> getUsageLimitRequest)

      Returns information about a usage limit.


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

      Parameters:
      getUsageLimitRequest - A Consumer that will call methods on GetUsageLimitRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetUsageLimit 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getWorkgroup

      default CompletableFuture<GetWorkgroupResponse> getWorkgroup(GetWorkgroupRequest getWorkgroupRequest)

      Returns information about a specific workgroup.

      Parameters:
      getWorkgroupRequest -
      Returns:
      A Java Future containing the result of the GetWorkgroup 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getWorkgroup

      default CompletableFuture<GetWorkgroupResponse> getWorkgroup(Consumer<GetWorkgroupRequest.Builder> getWorkgroupRequest)

      Returns information about a specific workgroup.


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

      Parameters:
      getWorkgroupRequest - A Consumer that will call methods on GetWorkgroupRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetWorkgroup 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listCustomDomainAssociations

      default CompletableFuture<ListCustomDomainAssociationsResponse> listCustomDomainAssociations(ListCustomDomainAssociationsRequest listCustomDomainAssociationsRequest)

      Lists custom domain associations for Amazon Redshift Serverless.

      Parameters:
      listCustomDomainAssociationsRequest -
      Returns:
      A Java Future containing the result of the ListCustomDomainAssociations 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • InvalidPaginationException The provided pagination token is invalid.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listCustomDomainAssociations

      default CompletableFuture<ListCustomDomainAssociationsResponse> listCustomDomainAssociations(Consumer<ListCustomDomainAssociationsRequest.Builder> listCustomDomainAssociationsRequest)

      Lists custom domain associations for Amazon Redshift Serverless.


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

      Parameters:
      listCustomDomainAssociationsRequest - A Consumer that will call methods on ListCustomDomainAssociationsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListCustomDomainAssociations 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • InvalidPaginationException The provided pagination token is invalid.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listCustomDomainAssociationsPaginator

      default ListCustomDomainAssociationsPublisher listCustomDomainAssociationsPaginator(ListCustomDomainAssociationsRequest listCustomDomainAssociationsRequest)

      This is a variant of listCustomDomainAssociations(software.amazon.awssdk.services.redshiftserverless.model.ListCustomDomainAssociationsRequest) 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.redshiftserverless.paginators.ListCustomDomainAssociationsPublisher publisher = client.listCustomDomainAssociationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListCustomDomainAssociationsPublisher publisher = client.listCustomDomainAssociationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListCustomDomainAssociationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListCustomDomainAssociationsResponse 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 listCustomDomainAssociations(software.amazon.awssdk.services.redshiftserverless.model.ListCustomDomainAssociationsRequest) operation.

      Parameters:
      listCustomDomainAssociationsRequest -
      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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • InvalidPaginationException The provided pagination token is invalid.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listCustomDomainAssociationsPaginator

      default ListCustomDomainAssociationsPublisher listCustomDomainAssociationsPaginator(Consumer<ListCustomDomainAssociationsRequest.Builder> listCustomDomainAssociationsRequest)

      This is a variant of listCustomDomainAssociations(software.amazon.awssdk.services.redshiftserverless.model.ListCustomDomainAssociationsRequest) 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.redshiftserverless.paginators.ListCustomDomainAssociationsPublisher publisher = client.listCustomDomainAssociationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListCustomDomainAssociationsPublisher publisher = client.listCustomDomainAssociationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListCustomDomainAssociationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListCustomDomainAssociationsResponse 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 listCustomDomainAssociations(software.amazon.awssdk.services.redshiftserverless.model.ListCustomDomainAssociationsRequest) operation.


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

      Parameters:
      listCustomDomainAssociationsRequest - A Consumer that will call methods on ListCustomDomainAssociationsRequest.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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • InvalidPaginationException The provided pagination token is invalid.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listEndpointAccess

      default CompletableFuture<ListEndpointAccessResponse> listEndpointAccess(ListEndpointAccessRequest listEndpointAccessRequest)

      Returns an array of EndpointAccess objects and relevant information.

      Parameters:
      listEndpointAccessRequest -
      Returns:
      A Java Future containing the result of the ListEndpointAccess 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listEndpointAccess

      default CompletableFuture<ListEndpointAccessResponse> listEndpointAccess(Consumer<ListEndpointAccessRequest.Builder> listEndpointAccessRequest)

      Returns an array of EndpointAccess objects and relevant information.


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

      Parameters:
      listEndpointAccessRequest - A Consumer that will call methods on ListEndpointAccessRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListEndpointAccess 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listEndpointAccessPaginator

      default ListEndpointAccessPublisher listEndpointAccessPaginator(ListEndpointAccessRequest listEndpointAccessRequest)

      This is a variant of listEndpointAccess(software.amazon.awssdk.services.redshiftserverless.model.ListEndpointAccessRequest) 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.redshiftserverless.paginators.ListEndpointAccessPublisher publisher = client.listEndpointAccessPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListEndpointAccessPublisher publisher = client.listEndpointAccessPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListEndpointAccessResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListEndpointAccessResponse 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 listEndpointAccess(software.amazon.awssdk.services.redshiftserverless.model.ListEndpointAccessRequest) operation.

      Parameters:
      listEndpointAccessRequest -
      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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listEndpointAccessPaginator

      default ListEndpointAccessPublisher listEndpointAccessPaginator(Consumer<ListEndpointAccessRequest.Builder> listEndpointAccessRequest)

      This is a variant of listEndpointAccess(software.amazon.awssdk.services.redshiftserverless.model.ListEndpointAccessRequest) 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.redshiftserverless.paginators.ListEndpointAccessPublisher publisher = client.listEndpointAccessPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListEndpointAccessPublisher publisher = client.listEndpointAccessPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListEndpointAccessResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListEndpointAccessResponse 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 listEndpointAccess(software.amazon.awssdk.services.redshiftserverless.model.ListEndpointAccessRequest) operation.


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

      Parameters:
      listEndpointAccessRequest - A Consumer that will call methods on ListEndpointAccessRequest.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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listManagedWorkgroups

      default CompletableFuture<ListManagedWorkgroupsResponse> listManagedWorkgroups(ListManagedWorkgroupsRequest listManagedWorkgroupsRequest)

      Returns information about a list of specified managed workgroups in your account.

      Parameters:
      listManagedWorkgroupsRequest -
      Returns:
      A Java Future containing the result of the ListManagedWorkgroups 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listManagedWorkgroups

      default CompletableFuture<ListManagedWorkgroupsResponse> listManagedWorkgroups(Consumer<ListManagedWorkgroupsRequest.Builder> listManagedWorkgroupsRequest)

      Returns information about a list of specified managed workgroups in your account.


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

      Parameters:
      listManagedWorkgroupsRequest - A Consumer that will call methods on ListManagedWorkgroupsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListManagedWorkgroups 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listManagedWorkgroupsPaginator

      default ListManagedWorkgroupsPublisher listManagedWorkgroupsPaginator(ListManagedWorkgroupsRequest listManagedWorkgroupsRequest)

      This is a variant of listManagedWorkgroups(software.amazon.awssdk.services.redshiftserverless.model.ListManagedWorkgroupsRequest) 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.redshiftserverless.paginators.ListManagedWorkgroupsPublisher publisher = client.listManagedWorkgroupsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListManagedWorkgroupsPublisher publisher = client.listManagedWorkgroupsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListManagedWorkgroupsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListManagedWorkgroupsResponse 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 listManagedWorkgroups(software.amazon.awssdk.services.redshiftserverless.model.ListManagedWorkgroupsRequest) operation.

      Parameters:
      listManagedWorkgroupsRequest -
      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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listManagedWorkgroupsPaginator

      default ListManagedWorkgroupsPublisher listManagedWorkgroupsPaginator(Consumer<ListManagedWorkgroupsRequest.Builder> listManagedWorkgroupsRequest)

      This is a variant of listManagedWorkgroups(software.amazon.awssdk.services.redshiftserverless.model.ListManagedWorkgroupsRequest) 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.redshiftserverless.paginators.ListManagedWorkgroupsPublisher publisher = client.listManagedWorkgroupsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListManagedWorkgroupsPublisher publisher = client.listManagedWorkgroupsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListManagedWorkgroupsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListManagedWorkgroupsResponse 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 listManagedWorkgroups(software.amazon.awssdk.services.redshiftserverless.model.ListManagedWorkgroupsRequest) operation.


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

      Parameters:
      listManagedWorkgroupsRequest - A Consumer that will call methods on ListManagedWorkgroupsRequest.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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listNamespaces

      default CompletableFuture<ListNamespacesResponse> listNamespaces(ListNamespacesRequest listNamespacesRequest)

      Returns information about a list of specified namespaces.

      Parameters:
      listNamespacesRequest -
      Returns:
      A Java Future containing the result of the ListNamespaces 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listNamespaces

      default CompletableFuture<ListNamespacesResponse> listNamespaces(Consumer<ListNamespacesRequest.Builder> listNamespacesRequest)

      Returns information about a list of specified namespaces.


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

      Parameters:
      listNamespacesRequest - A Consumer that will call methods on ListNamespacesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListNamespaces 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listNamespacesPaginator

      default ListNamespacesPublisher listNamespacesPaginator(ListNamespacesRequest listNamespacesRequest)

      This is a variant of listNamespaces(software.amazon.awssdk.services.redshiftserverless.model.ListNamespacesRequest) 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.redshiftserverless.paginators.ListNamespacesPublisher publisher = client.listNamespacesPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListNamespacesPublisher publisher = client.listNamespacesPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListNamespacesResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListNamespacesResponse 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 listNamespaces(software.amazon.awssdk.services.redshiftserverless.model.ListNamespacesRequest) operation.

      Parameters:
      listNamespacesRequest -
      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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listNamespacesPaginator

      default ListNamespacesPublisher listNamespacesPaginator(Consumer<ListNamespacesRequest.Builder> listNamespacesRequest)

      This is a variant of listNamespaces(software.amazon.awssdk.services.redshiftserverless.model.ListNamespacesRequest) 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.redshiftserverless.paginators.ListNamespacesPublisher publisher = client.listNamespacesPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListNamespacesPublisher publisher = client.listNamespacesPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListNamespacesResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListNamespacesResponse 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 listNamespaces(software.amazon.awssdk.services.redshiftserverless.model.ListNamespacesRequest) operation.


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

      Parameters:
      listNamespacesRequest - A Consumer that will call methods on ListNamespacesRequest.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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listRecoveryPoints

      default CompletableFuture<ListRecoveryPointsResponse> listRecoveryPoints(ListRecoveryPointsRequest listRecoveryPointsRequest)

      Returns an array of recovery points.

      Parameters:
      listRecoveryPointsRequest -
      Returns:
      A Java Future containing the result of the ListRecoveryPoints 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listRecoveryPoints

      default CompletableFuture<ListRecoveryPointsResponse> listRecoveryPoints(Consumer<ListRecoveryPointsRequest.Builder> listRecoveryPointsRequest)

      Returns an array of recovery points.


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

      Parameters:
      listRecoveryPointsRequest - A Consumer that will call methods on ListRecoveryPointsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListRecoveryPoints 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listRecoveryPointsPaginator

      default ListRecoveryPointsPublisher listRecoveryPointsPaginator(ListRecoveryPointsRequest listRecoveryPointsRequest)

      This is a variant of listRecoveryPoints(software.amazon.awssdk.services.redshiftserverless.model.ListRecoveryPointsRequest) 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.redshiftserverless.paginators.ListRecoveryPointsPublisher publisher = client.listRecoveryPointsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListRecoveryPointsPublisher publisher = client.listRecoveryPointsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListRecoveryPointsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListRecoveryPointsResponse 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 listRecoveryPoints(software.amazon.awssdk.services.redshiftserverless.model.ListRecoveryPointsRequest) operation.

      Parameters:
      listRecoveryPointsRequest -
      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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listRecoveryPointsPaginator

      default ListRecoveryPointsPublisher listRecoveryPointsPaginator(Consumer<ListRecoveryPointsRequest.Builder> listRecoveryPointsRequest)

      This is a variant of listRecoveryPoints(software.amazon.awssdk.services.redshiftserverless.model.ListRecoveryPointsRequest) 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.redshiftserverless.paginators.ListRecoveryPointsPublisher publisher = client.listRecoveryPointsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListRecoveryPointsPublisher publisher = client.listRecoveryPointsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListRecoveryPointsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListRecoveryPointsResponse 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 listRecoveryPoints(software.amazon.awssdk.services.redshiftserverless.model.ListRecoveryPointsRequest) operation.


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

      Parameters:
      listRecoveryPointsRequest - A Consumer that will call methods on ListRecoveryPointsRequest.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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listReservationOfferings

      default CompletableFuture<ListReservationOfferingsResponse> listReservationOfferings(ListReservationOfferingsRequest listReservationOfferingsRequest)

      Returns the current reservation offerings in your account.

      Parameters:
      listReservationOfferingsRequest -
      Returns:
      A Java Future containing the result of the ListReservationOfferings 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listReservationOfferings

      default CompletableFuture<ListReservationOfferingsResponse> listReservationOfferings(Consumer<ListReservationOfferingsRequest.Builder> listReservationOfferingsRequest)

      Returns the current reservation offerings in your account.


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

      Parameters:
      listReservationOfferingsRequest - A Consumer that will call methods on ListReservationOfferingsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListReservationOfferings 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listReservationOfferingsPaginator

      default ListReservationOfferingsPublisher listReservationOfferingsPaginator(ListReservationOfferingsRequest listReservationOfferingsRequest)

      This is a variant of listReservationOfferings(software.amazon.awssdk.services.redshiftserverless.model.ListReservationOfferingsRequest) 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.redshiftserverless.paginators.ListReservationOfferingsPublisher publisher = client.listReservationOfferingsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListReservationOfferingsPublisher publisher = client.listReservationOfferingsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListReservationOfferingsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListReservationOfferingsResponse 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 listReservationOfferings(software.amazon.awssdk.services.redshiftserverless.model.ListReservationOfferingsRequest) operation.

      Parameters:
      listReservationOfferingsRequest -
      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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listReservationOfferingsPaginator

      default ListReservationOfferingsPublisher listReservationOfferingsPaginator(Consumer<ListReservationOfferingsRequest.Builder> listReservationOfferingsRequest)

      This is a variant of listReservationOfferings(software.amazon.awssdk.services.redshiftserverless.model.ListReservationOfferingsRequest) 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.redshiftserverless.paginators.ListReservationOfferingsPublisher publisher = client.listReservationOfferingsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListReservationOfferingsPublisher publisher = client.listReservationOfferingsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListReservationOfferingsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListReservationOfferingsResponse 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 listReservationOfferings(software.amazon.awssdk.services.redshiftserverless.model.ListReservationOfferingsRequest) operation.


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

      Parameters:
      listReservationOfferingsRequest - A Consumer that will call methods on ListReservationOfferingsRequest.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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listReservations

      default CompletableFuture<ListReservationsResponse> listReservations(ListReservationsRequest listReservationsRequest)

      Returns a list of Reservation objects.

      Parameters:
      listReservationsRequest -
      Returns:
      A Java Future containing the result of the ListReservations 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listReservations

      default CompletableFuture<ListReservationsResponse> listReservations(Consumer<ListReservationsRequest.Builder> listReservationsRequest)

      Returns a list of Reservation objects.


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

      Parameters:
      listReservationsRequest - A Consumer that will call methods on ListReservationsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListReservations 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listReservationsPaginator

      default ListReservationsPublisher listReservationsPaginator(ListReservationsRequest listReservationsRequest)

      This is a variant of listReservations(software.amazon.awssdk.services.redshiftserverless.model.ListReservationsRequest) 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.redshiftserverless.paginators.ListReservationsPublisher publisher = client.listReservationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListReservationsPublisher publisher = client.listReservationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListReservationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListReservationsResponse 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 listReservations(software.amazon.awssdk.services.redshiftserverless.model.ListReservationsRequest) operation.

      Parameters:
      listReservationsRequest -
      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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listReservationsPaginator

      default ListReservationsPublisher listReservationsPaginator(Consumer<ListReservationsRequest.Builder> listReservationsRequest)

      This is a variant of listReservations(software.amazon.awssdk.services.redshiftserverless.model.ListReservationsRequest) 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.redshiftserverless.paginators.ListReservationsPublisher publisher = client.listReservationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListReservationsPublisher publisher = client.listReservationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListReservationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListReservationsResponse 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 listReservations(software.amazon.awssdk.services.redshiftserverless.model.ListReservationsRequest) operation.


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

      Parameters:
      listReservationsRequest - A Consumer that will call methods on ListReservationsRequest.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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listScheduledActions

      default CompletableFuture<ListScheduledActionsResponse> listScheduledActions(ListScheduledActionsRequest listScheduledActionsRequest)

      Returns a list of scheduled actions. You can use the flags to filter the list of returned scheduled actions.

      Parameters:
      listScheduledActionsRequest -
      Returns:
      A Java Future containing the result of the ListScheduledActions 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • InvalidPaginationException The provided pagination token is invalid.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listScheduledActions

      default CompletableFuture<ListScheduledActionsResponse> listScheduledActions(Consumer<ListScheduledActionsRequest.Builder> listScheduledActionsRequest)

      Returns a list of scheduled actions. You can use the flags to filter the list of returned scheduled actions.


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

      Parameters:
      listScheduledActionsRequest - A Consumer that will call methods on ListScheduledActionsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListScheduledActions 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • InvalidPaginationException The provided pagination token is invalid.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listScheduledActionsPaginator

      default ListScheduledActionsPublisher listScheduledActionsPaginator(ListScheduledActionsRequest listScheduledActionsRequest)

      This is a variant of listScheduledActions(software.amazon.awssdk.services.redshiftserverless.model.ListScheduledActionsRequest) 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.redshiftserverless.paginators.ListScheduledActionsPublisher publisher = client.listScheduledActionsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListScheduledActionsPublisher publisher = client.listScheduledActionsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListScheduledActionsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListScheduledActionsResponse 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 listScheduledActions(software.amazon.awssdk.services.redshiftserverless.model.ListScheduledActionsRequest) operation.

      Parameters:
      listScheduledActionsRequest -
      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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • InvalidPaginationException The provided pagination token is invalid.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listScheduledActionsPaginator

      default ListScheduledActionsPublisher listScheduledActionsPaginator(Consumer<ListScheduledActionsRequest.Builder> listScheduledActionsRequest)

      This is a variant of listScheduledActions(software.amazon.awssdk.services.redshiftserverless.model.ListScheduledActionsRequest) 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.redshiftserverless.paginators.ListScheduledActionsPublisher publisher = client.listScheduledActionsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListScheduledActionsPublisher publisher = client.listScheduledActionsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListScheduledActionsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListScheduledActionsResponse 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 listScheduledActions(software.amazon.awssdk.services.redshiftserverless.model.ListScheduledActionsRequest) operation.


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

      Parameters:
      listScheduledActionsRequest - A Consumer that will call methods on ListScheduledActionsRequest.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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • InvalidPaginationException The provided pagination token is invalid.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSnapshotCopyConfigurations

      default CompletableFuture<ListSnapshotCopyConfigurationsResponse> listSnapshotCopyConfigurations(ListSnapshotCopyConfigurationsRequest listSnapshotCopyConfigurationsRequest)

      Returns a list of snapshot copy configurations.

      Parameters:
      listSnapshotCopyConfigurationsRequest -
      Returns:
      A Java Future containing the result of the ListSnapshotCopyConfigurations 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • InvalidPaginationException The provided pagination token is invalid.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSnapshotCopyConfigurations

      default CompletableFuture<ListSnapshotCopyConfigurationsResponse> listSnapshotCopyConfigurations(Consumer<ListSnapshotCopyConfigurationsRequest.Builder> listSnapshotCopyConfigurationsRequest)

      Returns a list of snapshot copy configurations.


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

      Parameters:
      listSnapshotCopyConfigurationsRequest - A Consumer that will call methods on ListSnapshotCopyConfigurationsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListSnapshotCopyConfigurations 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • InvalidPaginationException The provided pagination token is invalid.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSnapshotCopyConfigurationsPaginator

      default ListSnapshotCopyConfigurationsPublisher listSnapshotCopyConfigurationsPaginator(ListSnapshotCopyConfigurationsRequest listSnapshotCopyConfigurationsRequest)

      This is a variant of listSnapshotCopyConfigurations(software.amazon.awssdk.services.redshiftserverless.model.ListSnapshotCopyConfigurationsRequest) 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.redshiftserverless.paginators.ListSnapshotCopyConfigurationsPublisher publisher = client.listSnapshotCopyConfigurationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListSnapshotCopyConfigurationsPublisher publisher = client.listSnapshotCopyConfigurationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListSnapshotCopyConfigurationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListSnapshotCopyConfigurationsResponse 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 listSnapshotCopyConfigurations(software.amazon.awssdk.services.redshiftserverless.model.ListSnapshotCopyConfigurationsRequest) operation.

      Parameters:
      listSnapshotCopyConfigurationsRequest -
      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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • InvalidPaginationException The provided pagination token is invalid.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSnapshotCopyConfigurationsPaginator

      default ListSnapshotCopyConfigurationsPublisher listSnapshotCopyConfigurationsPaginator(Consumer<ListSnapshotCopyConfigurationsRequest.Builder> listSnapshotCopyConfigurationsRequest)

      This is a variant of listSnapshotCopyConfigurations(software.amazon.awssdk.services.redshiftserverless.model.ListSnapshotCopyConfigurationsRequest) 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.redshiftserverless.paginators.ListSnapshotCopyConfigurationsPublisher publisher = client.listSnapshotCopyConfigurationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListSnapshotCopyConfigurationsPublisher publisher = client.listSnapshotCopyConfigurationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListSnapshotCopyConfigurationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListSnapshotCopyConfigurationsResponse 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 listSnapshotCopyConfigurations(software.amazon.awssdk.services.redshiftserverless.model.ListSnapshotCopyConfigurationsRequest) operation.


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

      Parameters:
      listSnapshotCopyConfigurationsRequest - A Consumer that will call methods on ListSnapshotCopyConfigurationsRequest.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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • InvalidPaginationException The provided pagination token is invalid.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSnapshots

      default CompletableFuture<ListSnapshotsResponse> listSnapshots(ListSnapshotsRequest listSnapshotsRequest)

      Returns a list of snapshots.

      Parameters:
      listSnapshotsRequest -
      Returns:
      A Java Future containing the result of the ListSnapshots 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSnapshots

      default CompletableFuture<ListSnapshotsResponse> listSnapshots(Consumer<ListSnapshotsRequest.Builder> listSnapshotsRequest)

      Returns a list of snapshots.


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

      Parameters:
      listSnapshotsRequest - A Consumer that will call methods on ListSnapshotsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListSnapshots 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSnapshotsPaginator

      default ListSnapshotsPublisher listSnapshotsPaginator(ListSnapshotsRequest listSnapshotsRequest)

      This is a variant of listSnapshots(software.amazon.awssdk.services.redshiftserverless.model.ListSnapshotsRequest) 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.redshiftserverless.paginators.ListSnapshotsPublisher publisher = client.listSnapshotsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListSnapshotsPublisher publisher = client.listSnapshotsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListSnapshotsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListSnapshotsResponse 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 listSnapshots(software.amazon.awssdk.services.redshiftserverless.model.ListSnapshotsRequest) operation.

      Parameters:
      listSnapshotsRequest -
      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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSnapshotsPaginator

      default ListSnapshotsPublisher listSnapshotsPaginator(Consumer<ListSnapshotsRequest.Builder> listSnapshotsRequest)

      This is a variant of listSnapshots(software.amazon.awssdk.services.redshiftserverless.model.ListSnapshotsRequest) 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.redshiftserverless.paginators.ListSnapshotsPublisher publisher = client.listSnapshotsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListSnapshotsPublisher publisher = client.listSnapshotsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListSnapshotsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListSnapshotsResponse 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 listSnapshots(software.amazon.awssdk.services.redshiftserverless.model.ListSnapshotsRequest) operation.


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

      Parameters:
      listSnapshotsRequest - A Consumer that will call methods on ListSnapshotsRequest.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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTableRestoreStatus

      default CompletableFuture<ListTableRestoreStatusResponse> listTableRestoreStatus(ListTableRestoreStatusRequest listTableRestoreStatusRequest)

      Returns information about an array of TableRestoreStatus objects.

      Parameters:
      listTableRestoreStatusRequest -
      Returns:
      A Java Future containing the result of the ListTableRestoreStatus 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.
      • InvalidPaginationException The provided pagination token is invalid.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTableRestoreStatus

      default CompletableFuture<ListTableRestoreStatusResponse> listTableRestoreStatus(Consumer<ListTableRestoreStatusRequest.Builder> listTableRestoreStatusRequest)

      Returns information about an array of TableRestoreStatus objects.


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

      Parameters:
      listTableRestoreStatusRequest - A Consumer that will call methods on ListTableRestoreStatusRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListTableRestoreStatus 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.
      • InvalidPaginationException The provided pagination token is invalid.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTableRestoreStatusPaginator

      default ListTableRestoreStatusPublisher listTableRestoreStatusPaginator(ListTableRestoreStatusRequest listTableRestoreStatusRequest)

      This is a variant of listTableRestoreStatus(software.amazon.awssdk.services.redshiftserverless.model.ListTableRestoreStatusRequest) 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.redshiftserverless.paginators.ListTableRestoreStatusPublisher publisher = client.listTableRestoreStatusPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListTableRestoreStatusPublisher publisher = client.listTableRestoreStatusPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListTableRestoreStatusResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListTableRestoreStatusResponse 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 listTableRestoreStatus(software.amazon.awssdk.services.redshiftserverless.model.ListTableRestoreStatusRequest) operation.

      Parameters:
      listTableRestoreStatusRequest -
      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.
      • InvalidPaginationException The provided pagination token is invalid.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTableRestoreStatusPaginator

      default ListTableRestoreStatusPublisher listTableRestoreStatusPaginator(Consumer<ListTableRestoreStatusRequest.Builder> listTableRestoreStatusRequest)

      This is a variant of listTableRestoreStatus(software.amazon.awssdk.services.redshiftserverless.model.ListTableRestoreStatusRequest) 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.redshiftserverless.paginators.ListTableRestoreStatusPublisher publisher = client.listTableRestoreStatusPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListTableRestoreStatusPublisher publisher = client.listTableRestoreStatusPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListTableRestoreStatusResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListTableRestoreStatusResponse 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 listTableRestoreStatus(software.amazon.awssdk.services.redshiftserverless.model.ListTableRestoreStatusRequest) operation.


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

      Parameters:
      listTableRestoreStatusRequest - A Consumer that will call methods on ListTableRestoreStatusRequest.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.
      • InvalidPaginationException The provided pagination token is invalid.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException 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)

      Lists the tags assigned to a resource.

      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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • ThrottlingException The 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.
      • RedshiftServerlessException 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)

      Lists the tags assigned to a resource.


      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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTracks

      default CompletableFuture<ListTracksResponse> listTracks(ListTracksRequest listTracksRequest)

      List the Amazon Redshift Serverless versions.

      Parameters:
      listTracksRequest -
      Returns:
      A Java Future containing the result of the ListTracks 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • InvalidPaginationException The provided pagination token is invalid.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTracks

      default CompletableFuture<ListTracksResponse> listTracks(Consumer<ListTracksRequest.Builder> listTracksRequest)

      List the Amazon Redshift Serverless versions.


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

      Parameters:
      listTracksRequest - A Consumer that will call methods on ListTracksRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListTracks 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • InvalidPaginationException The provided pagination token is invalid.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTracksPaginator

      default ListTracksPublisher listTracksPaginator(ListTracksRequest listTracksRequest)

      This is a variant of listTracks(software.amazon.awssdk.services.redshiftserverless.model.ListTracksRequest) 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.redshiftserverless.paginators.ListTracksPublisher publisher = client.listTracksPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListTracksPublisher publisher = client.listTracksPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListTracksResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListTracksResponse 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 listTracks(software.amazon.awssdk.services.redshiftserverless.model.ListTracksRequest) operation.

      Parameters:
      listTracksRequest -
      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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • InvalidPaginationException The provided pagination token is invalid.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTracksPaginator

      default ListTracksPublisher listTracksPaginator(Consumer<ListTracksRequest.Builder> listTracksRequest)

      This is a variant of listTracks(software.amazon.awssdk.services.redshiftserverless.model.ListTracksRequest) 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.redshiftserverless.paginators.ListTracksPublisher publisher = client.listTracksPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListTracksPublisher publisher = client.listTracksPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListTracksResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListTracksResponse 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 listTracks(software.amazon.awssdk.services.redshiftserverless.model.ListTracksRequest) operation.


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

      Parameters:
      listTracksRequest - A Consumer that will call methods on ListTracksRequest.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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • InvalidPaginationException The provided pagination token is invalid.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listUsageLimits

      default CompletableFuture<ListUsageLimitsResponse> listUsageLimits(ListUsageLimitsRequest listUsageLimitsRequest)

      Lists all usage limits within Amazon Redshift Serverless.

      Parameters:
      listUsageLimitsRequest -
      Returns:
      A Java Future containing the result of the ListUsageLimits 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • InvalidPaginationException The provided pagination token is invalid.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listUsageLimits

      default CompletableFuture<ListUsageLimitsResponse> listUsageLimits(Consumer<ListUsageLimitsRequest.Builder> listUsageLimitsRequest)

      Lists all usage limits within Amazon Redshift Serverless.


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

      Parameters:
      listUsageLimitsRequest - A Consumer that will call methods on ListUsageLimitsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListUsageLimits 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • InvalidPaginationException The provided pagination token is invalid.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listUsageLimitsPaginator

      default ListUsageLimitsPublisher listUsageLimitsPaginator(ListUsageLimitsRequest listUsageLimitsRequest)

      This is a variant of listUsageLimits(software.amazon.awssdk.services.redshiftserverless.model.ListUsageLimitsRequest) 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.redshiftserverless.paginators.ListUsageLimitsPublisher publisher = client.listUsageLimitsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListUsageLimitsPublisher publisher = client.listUsageLimitsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListUsageLimitsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListUsageLimitsResponse 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 listUsageLimits(software.amazon.awssdk.services.redshiftserverless.model.ListUsageLimitsRequest) operation.

      Parameters:
      listUsageLimitsRequest -
      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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • InvalidPaginationException The provided pagination token is invalid.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listUsageLimitsPaginator

      default ListUsageLimitsPublisher listUsageLimitsPaginator(Consumer<ListUsageLimitsRequest.Builder> listUsageLimitsRequest)

      This is a variant of listUsageLimits(software.amazon.awssdk.services.redshiftserverless.model.ListUsageLimitsRequest) 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.redshiftserverless.paginators.ListUsageLimitsPublisher publisher = client.listUsageLimitsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListUsageLimitsPublisher publisher = client.listUsageLimitsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListUsageLimitsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListUsageLimitsResponse 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 listUsageLimits(software.amazon.awssdk.services.redshiftserverless.model.ListUsageLimitsRequest) operation.


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

      Parameters:
      listUsageLimitsRequest - A Consumer that will call methods on ListUsageLimitsRequest.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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • InvalidPaginationException The provided pagination token is invalid.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listWorkgroups

      default CompletableFuture<ListWorkgroupsResponse> listWorkgroups(ListWorkgroupsRequest listWorkgroupsRequest)

      Returns information about a list of specified workgroups.

      Parameters:
      listWorkgroupsRequest -
      Returns:
      A Java Future containing the result of the ListWorkgroups 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listWorkgroups

      default CompletableFuture<ListWorkgroupsResponse> listWorkgroups(Consumer<ListWorkgroupsRequest.Builder> listWorkgroupsRequest)

      Returns information about a list of specified workgroups.


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

      Parameters:
      listWorkgroupsRequest - A Consumer that will call methods on ListWorkgroupsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListWorkgroups 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listWorkgroupsPaginator

      default ListWorkgroupsPublisher listWorkgroupsPaginator(ListWorkgroupsRequest listWorkgroupsRequest)

      This is a variant of listWorkgroups(software.amazon.awssdk.services.redshiftserverless.model.ListWorkgroupsRequest) 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.redshiftserverless.paginators.ListWorkgroupsPublisher publisher = client.listWorkgroupsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListWorkgroupsPublisher publisher = client.listWorkgroupsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListWorkgroupsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListWorkgroupsResponse 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 listWorkgroups(software.amazon.awssdk.services.redshiftserverless.model.ListWorkgroupsRequest) operation.

      Parameters:
      listWorkgroupsRequest -
      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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listWorkgroupsPaginator

      default ListWorkgroupsPublisher listWorkgroupsPaginator(Consumer<ListWorkgroupsRequest.Builder> listWorkgroupsRequest)

      This is a variant of listWorkgroups(software.amazon.awssdk.services.redshiftserverless.model.ListWorkgroupsRequest) 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.redshiftserverless.paginators.ListWorkgroupsPublisher publisher = client.listWorkgroupsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.redshiftserverless.paginators.ListWorkgroupsPublisher publisher = client.listWorkgroupsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.redshiftserverless.model.ListWorkgroupsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.redshiftserverless.model.ListWorkgroupsResponse 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 listWorkgroups(software.amazon.awssdk.services.redshiftserverless.model.ListWorkgroupsRequest) operation.


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

      Parameters:
      listWorkgroupsRequest - A Consumer that will call methods on ListWorkgroupsRequest.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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • putResourcePolicy

      default CompletableFuture<PutResourcePolicyResponse> putResourcePolicy(PutResourcePolicyRequest putResourcePolicyRequest)

      Creates or updates a resource policy. Currently, you can use policies to share snapshots across Amazon Web Services accounts.

      Parameters:
      putResourcePolicyRequest -
      Returns:
      A Java Future containing the result of the PutResourcePolicy 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • ServiceQuotaExceededException The service limit was exceeded.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • putResourcePolicy

      default CompletableFuture<PutResourcePolicyResponse> putResourcePolicy(Consumer<PutResourcePolicyRequest.Builder> putResourcePolicyRequest)

      Creates or updates a resource policy. Currently, you can use policies to share snapshots across Amazon Web Services accounts.


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

      Parameters:
      putResourcePolicyRequest - A Consumer that will call methods on PutResourcePolicyRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the PutResourcePolicy 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • ServiceQuotaExceededException The service limit was exceeded.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • restoreFromRecoveryPoint

      default CompletableFuture<RestoreFromRecoveryPointResponse> restoreFromRecoveryPoint(RestoreFromRecoveryPointRequest restoreFromRecoveryPointRequest)

      Restore the data from a recovery point.

      Parameters:
      restoreFromRecoveryPointRequest -
      Returns:
      A Java Future containing the result of the RestoreFromRecoveryPoint 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • restoreFromRecoveryPoint

      default CompletableFuture<RestoreFromRecoveryPointResponse> restoreFromRecoveryPoint(Consumer<RestoreFromRecoveryPointRequest.Builder> restoreFromRecoveryPointRequest)

      Restore the data from a recovery point.


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

      Parameters:
      restoreFromRecoveryPointRequest - A Consumer that will call methods on RestoreFromRecoveryPointRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the RestoreFromRecoveryPoint 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • restoreFromSnapshot

      default CompletableFuture<RestoreFromSnapshotResponse> restoreFromSnapshot(RestoreFromSnapshotRequest restoreFromSnapshotRequest)

      Restores a namespace from a snapshot.

      Parameters:
      restoreFromSnapshotRequest -
      Returns:
      A Java Future containing the result of the RestoreFromSnapshot 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • ServiceQuotaExceededException The service limit was exceeded.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • restoreFromSnapshot

      default CompletableFuture<RestoreFromSnapshotResponse> restoreFromSnapshot(Consumer<RestoreFromSnapshotRequest.Builder> restoreFromSnapshotRequest)

      Restores a namespace from a snapshot.


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

      Parameters:
      restoreFromSnapshotRequest - A Consumer that will call methods on RestoreFromSnapshotRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the RestoreFromSnapshot 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • ServiceQuotaExceededException The service limit was exceeded.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • restoreTableFromRecoveryPoint

      default CompletableFuture<RestoreTableFromRecoveryPointResponse> restoreTableFromRecoveryPoint(RestoreTableFromRecoveryPointRequest restoreTableFromRecoveryPointRequest)

      Restores a table from a recovery point to your Amazon Redshift Serverless instance. You can't use this operation to restore tables with interleaved sort keys.

      Parameters:
      restoreTableFromRecoveryPointRequest -
      Returns:
      A Java Future containing the result of the RestoreTableFromRecoveryPoint 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • restoreTableFromRecoveryPoint

      default CompletableFuture<RestoreTableFromRecoveryPointResponse> restoreTableFromRecoveryPoint(Consumer<RestoreTableFromRecoveryPointRequest.Builder> restoreTableFromRecoveryPointRequest)

      Restores a table from a recovery point to your Amazon Redshift Serverless instance. You can't use this operation to restore tables with interleaved sort keys.


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

      Parameters:
      restoreTableFromRecoveryPointRequest - A Consumer that will call methods on RestoreTableFromRecoveryPointRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the RestoreTableFromRecoveryPoint 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • restoreTableFromSnapshot

      default CompletableFuture<RestoreTableFromSnapshotResponse> restoreTableFromSnapshot(RestoreTableFromSnapshotRequest restoreTableFromSnapshotRequest)

      Restores a table from a snapshot to your Amazon Redshift Serverless instance. You can't use this operation to restore tables with interleaved sort keys.

      Parameters:
      restoreTableFromSnapshotRequest -
      Returns:
      A Java Future containing the result of the RestoreTableFromSnapshot 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • restoreTableFromSnapshot

      default CompletableFuture<RestoreTableFromSnapshotResponse> restoreTableFromSnapshot(Consumer<RestoreTableFromSnapshotRequest.Builder> restoreTableFromSnapshotRequest)

      Restores a table from a snapshot to your Amazon Redshift Serverless instance. You can't use this operation to restore tables with interleaved sort keys.


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

      Parameters:
      restoreTableFromSnapshotRequest - A Consumer that will call methods on RestoreTableFromSnapshotRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the RestoreTableFromSnapshot 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException 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)

      Assigns one or more tags to a resource.

      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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • TooManyTagsException The request exceeded the number of tags allowed for a resource.
      • ThrottlingException The 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.
      • RedshiftServerlessException 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)

      Assigns one or more tags to a resource.


      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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • TooManyTagsException The request exceeded the number of tags allowed for a resource.
      • ThrottlingException The 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.
      • RedshiftServerlessException 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)

      Removes a tag or set of tags from a resource.

      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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • ThrottlingException The 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.
      • RedshiftServerlessException 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)

      Removes a tag or set of tags from a resource.


      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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateCustomDomainAssociation

      default CompletableFuture<UpdateCustomDomainAssociationResponse> updateCustomDomainAssociation(UpdateCustomDomainAssociationRequest updateCustomDomainAssociationRequest)

      Updates an Amazon Redshift Serverless certificate associated with a custom domain.

      Parameters:
      updateCustomDomainAssociationRequest -
      Returns:
      A Java Future containing the result of the UpdateCustomDomainAssociation 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateCustomDomainAssociation

      default CompletableFuture<UpdateCustomDomainAssociationResponse> updateCustomDomainAssociation(Consumer<UpdateCustomDomainAssociationRequest.Builder> updateCustomDomainAssociationRequest)

      Updates an Amazon Redshift Serverless certificate associated with a custom domain.


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

      Parameters:
      updateCustomDomainAssociationRequest - A Consumer that will call methods on UpdateCustomDomainAssociationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateCustomDomainAssociation 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • ThrottlingException The 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateEndpointAccess

      default CompletableFuture<UpdateEndpointAccessResponse> updateEndpointAccess(UpdateEndpointAccessRequest updateEndpointAccessRequest)

      Updates an Amazon Redshift Serverless managed endpoint.

      Parameters:
      updateEndpointAccessRequest -
      Returns:
      A Java Future containing the result of the UpdateEndpointAccess 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateEndpointAccess

      default CompletableFuture<UpdateEndpointAccessResponse> updateEndpointAccess(Consumer<UpdateEndpointAccessRequest.Builder> updateEndpointAccessRequest)

      Updates an Amazon Redshift Serverless managed endpoint.


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

      Parameters:
      updateEndpointAccessRequest - A Consumer that will call methods on UpdateEndpointAccessRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateEndpointAccess 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateNamespace

      default CompletableFuture<UpdateNamespaceResponse> updateNamespace(UpdateNamespaceRequest updateNamespaceRequest)

      Updates a namespace with the specified settings. Unless required, you can't update multiple parameters in one request. For example, you must specify both adminUsername and adminUserPassword to update either field, but you can't update both kmsKeyId and logExports in a single request.

      Parameters:
      updateNamespaceRequest -
      Returns:
      A Java Future containing the result of the UpdateNamespace 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateNamespace

      default CompletableFuture<UpdateNamespaceResponse> updateNamespace(Consumer<UpdateNamespaceRequest.Builder> updateNamespaceRequest)

      Updates a namespace with the specified settings. Unless required, you can't update multiple parameters in one request. For example, you must specify both adminUsername and adminUserPassword to update either field, but you can't update both kmsKeyId and logExports in a single request.


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

      Parameters:
      updateNamespaceRequest - A Consumer that will call methods on UpdateNamespaceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateNamespace 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateScheduledAction

      default CompletableFuture<UpdateScheduledActionResponse> updateScheduledAction(UpdateScheduledActionRequest updateScheduledActionRequest)

      Updates a scheduled action.

      Parameters:
      updateScheduledActionRequest -
      Returns:
      A Java Future containing the result of the UpdateScheduledAction 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateScheduledAction

      default CompletableFuture<UpdateScheduledActionResponse> updateScheduledAction(Consumer<UpdateScheduledActionRequest.Builder> updateScheduledActionRequest)

      Updates a scheduled action.


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

      Parameters:
      updateScheduledActionRequest - A Consumer that will call methods on UpdateScheduledActionRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateScheduledAction 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateSnapshot

      default CompletableFuture<UpdateSnapshotResponse> updateSnapshot(UpdateSnapshotRequest updateSnapshotRequest)

      Updates a snapshot.

      Parameters:
      updateSnapshotRequest -
      Returns:
      A Java Future containing the result of the UpdateSnapshot 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateSnapshot

      default CompletableFuture<UpdateSnapshotResponse> updateSnapshot(Consumer<UpdateSnapshotRequest.Builder> updateSnapshotRequest)

      Updates a snapshot.


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

      Parameters:
      updateSnapshotRequest - A Consumer that will call methods on UpdateSnapshotRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateSnapshot 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateSnapshotCopyConfiguration

      default CompletableFuture<UpdateSnapshotCopyConfigurationResponse> updateSnapshotCopyConfiguration(UpdateSnapshotCopyConfigurationRequest updateSnapshotCopyConfigurationRequest)

      Updates a snapshot copy configuration.

      Parameters:
      updateSnapshotCopyConfigurationRequest -
      Returns:
      A Java Future containing the result of the UpdateSnapshotCopyConfiguration 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateSnapshotCopyConfiguration

      default CompletableFuture<UpdateSnapshotCopyConfigurationResponse> updateSnapshotCopyConfiguration(Consumer<UpdateSnapshotCopyConfigurationRequest.Builder> updateSnapshotCopyConfigurationRequest)

      Updates a snapshot copy configuration.


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

      Parameters:
      updateSnapshotCopyConfigurationRequest - A Consumer that will call methods on UpdateSnapshotCopyConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateSnapshotCopyConfiguration 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • AccessDeniedException You do not have sufficient access to perform this action.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateUsageLimit

      default CompletableFuture<UpdateUsageLimitResponse> updateUsageLimit(UpdateUsageLimitRequest updateUsageLimitRequest)

      Update a usage limit in Amazon Redshift Serverless. You can't update the usage type or period of a usage limit.

      Parameters:
      updateUsageLimitRequest -
      Returns:
      A Java Future containing the result of the UpdateUsageLimit 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateUsageLimit

      default CompletableFuture<UpdateUsageLimitResponse> updateUsageLimit(Consumer<UpdateUsageLimitRequest.Builder> updateUsageLimitRequest)

      Update a usage limit in Amazon Redshift Serverless. You can't update the usage type or period of a usage limit.


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

      Parameters:
      updateUsageLimitRequest - A Consumer that will call methods on UpdateUsageLimitRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateUsageLimit 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateWorkgroup

      default CompletableFuture<UpdateWorkgroupResponse> updateWorkgroup(UpdateWorkgroupRequest updateWorkgroupRequest)

      Updates a workgroup with the specified configuration settings. You can't update multiple parameters in one request. For example, you can update baseCapacity or port in a single request, but you can't update both in the same request.

      VPC Block Public Access (BPA) enables you to block resources in VPCs and subnets that you own in a Region from reaching or being reached from the internet through internet gateways and egress-only internet gateways. If a workgroup is in an account with VPC BPA turned on, the following capabilities are blocked:

      • Creating a public access workgroup

      • Modifying a private workgroup to public

      • Adding a subnet with VPC BPA turned on to the workgroup when the workgroup is public

      For more information about VPC BPA, see Block public access to VPCs and subnets in the Amazon VPC User Guide.

      Parameters:
      updateWorkgroupRequest -
      Returns:
      A Java Future containing the result of the UpdateWorkgroup 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • InsufficientCapacityException There is an insufficient capacity to perform the action.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • Ipv6CidrBlockNotFoundException There are no subnets in your VPC with associated IPv6 CIDR blocks. To use dual-stack mode, associate an IPv6 CIDR block with each subnet in your VPC.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateWorkgroup

      default CompletableFuture<UpdateWorkgroupResponse> updateWorkgroup(Consumer<UpdateWorkgroupRequest.Builder> updateWorkgroupRequest)

      Updates a workgroup with the specified configuration settings. You can't update multiple parameters in one request. For example, you can update baseCapacity or port in a single request, but you can't update both in the same request.

      VPC Block Public Access (BPA) enables you to block resources in VPCs and subnets that you own in a Region from reaching or being reached from the internet through internet gateways and egress-only internet gateways. If a workgroup is in an account with VPC BPA turned on, the following capabilities are blocked:

      • Creating a public access workgroup

      • Modifying a private workgroup to public

      • Adding a subnet with VPC BPA turned on to the workgroup when the workgroup is public

      For more information about VPC BPA, see Block public access to VPCs and subnets in the Amazon VPC User Guide.


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

      Parameters:
      updateWorkgroupRequest - A Consumer that will call methods on UpdateWorkgroupRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateWorkgroup 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.
      • InternalServerException The request processing has failed because of an unknown error, exception or failure.
      • InsufficientCapacityException There is an insufficient capacity to perform the action.
      • ResourceNotFoundException The resource could not be found.
      • ConflictException The submitted action has conflicts.
      • ValidationException The input failed to satisfy the constraints specified by an AWS service.
      • Ipv6CidrBlockNotFoundException There are no subnets in your VPC with associated IPv6 CIDR blocks. To use dual-stack mode, associate an IPv6 CIDR block with each subnet in your VPC.
      • 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.
      • RedshiftServerlessException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • serviceClientConfiguration

      default RedshiftServerlessServiceClientConfiguration 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 RedshiftServerlessAsyncClient create()
      Create a RedshiftServerlessAsyncClient with the region loaded from the DefaultAwsRegionProviderChain and credentials loaded from the DefaultCredentialsProvider.

    • builder

      static RedshiftServerlessAsyncClientBuilder builder()
      Create a builder that can be used to configure and create a RedshiftServerlessAsyncClient.