Interface IvsRealTimeAsyncClient

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

The Amazon Interactive Video Service (IVS) real-time API is REST compatible, using a standard HTTP API and an AWS EventBridge event stream for responses. JSON is used for both requests and responses, including errors.

Key Concepts

  • Stage — A virtual space where participants can exchange video in real time.

  • Participant token — A token that authenticates a participant when they join a stage.

  • Participant object — Represents participants (people) in the stage and contains information about them. When a token is created, it includes a participant ID; when a participant uses that token to join a stage, the participant is associated with that participant ID. There is a 1:1 mapping between participant tokens and participants.

For server-side composition:

  • Composition process — Composites participants of a stage into a single video and forwards it to a set of outputs (e.g., IVS channels). Composition operations support this process.

  • Composition — Controls the look of the outputs, including how participants are positioned in the video.

For participant replication:

  • Source stage — The stage where the participant originally joined, which is used as the source for replication.

  • Destination stage — The stage to which the participant is replicated.

  • Replicated participant — A participant in a stage that is replicated to one or more destination stages.

  • Replica participant — A participant in a destination stage that is replicated from another stage (the source stage).

For more information about your IVS live stream, also see Getting Started with Amazon IVS Real-Time Streaming.

Tagging

A tag is a metadata label that you assign to an AWS resource. A tag comprises a key and a value, both set by you. For example, you might set a tag as topic:nature to label a particular video category. See Best practices and strategies in Tagging AWS Resources and Tag Editor for details, including restrictions that apply to tags and "Tag naming limits and requirements"; Amazon IVS stages has no service-specific constraints beyond what is documented there.

Tags can help you identify and organize your AWS resources. For example, you can use the same tag for different resources to indicate that they are related. You can also use tags to manage access (see Access Tags).

The Amazon IVS real-time API has these tag-related operations: TagResource, UntagResource, and ListTagsForResource. The following resource supports tagging: Stage.

At most 50 tags can be applied to a resource.

  • Field Details

  • Method Details

    • createEncoderConfiguration

      default CompletableFuture<CreateEncoderConfigurationResponse> createEncoderConfiguration(CreateEncoderConfigurationRequest createEncoderConfigurationRequest)

      Creates an EncoderConfiguration object.

      Parameters:
      createEncoderConfigurationRequest -
      Returns:
      A Java Future containing the result of the CreateEncoderConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createEncoderConfiguration

      default CompletableFuture<CreateEncoderConfigurationResponse> createEncoderConfiguration(Consumer<CreateEncoderConfigurationRequest.Builder> createEncoderConfigurationRequest)

      Creates an EncoderConfiguration object.


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

      Parameters:
      createEncoderConfigurationRequest - A Consumer that will call methods on CreateEncoderConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateEncoderConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createIngestConfiguration

      default CompletableFuture<CreateIngestConfigurationResponse> createIngestConfiguration(CreateIngestConfigurationRequest createIngestConfigurationRequest)

      Creates a new IngestConfiguration resource, used to specify the ingest protocol for a stage.

      Parameters:
      createIngestConfigurationRequest -
      Returns:
      A Java Future containing the result of the CreateIngestConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException
      • AccessDeniedException
      • ServiceQuotaExceededException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createIngestConfiguration

      default CompletableFuture<CreateIngestConfigurationResponse> createIngestConfiguration(Consumer<CreateIngestConfigurationRequest.Builder> createIngestConfigurationRequest)

      Creates a new IngestConfiguration resource, used to specify the ingest protocol for a stage.


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

      Parameters:
      createIngestConfigurationRequest - A Consumer that will call methods on CreateIngestConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateIngestConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException
      • AccessDeniedException
      • ServiceQuotaExceededException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createParticipantToken

      default CompletableFuture<CreateParticipantTokenResponse> createParticipantToken(CreateParticipantTokenRequest createParticipantTokenRequest)

      Creates an additional token for a specified stage. This can be done after stage creation or when tokens expire. Tokens always are scoped to the stage for which they are created.

      Encryption keys are owned by Amazon IVS and never used directly by your application.

      Parameters:
      createParticipantTokenRequest -
      Returns:
      A Java Future containing the result of the CreateParticipantToken operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • ServiceQuotaExceededException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createParticipantToken

      default CompletableFuture<CreateParticipantTokenResponse> createParticipantToken(Consumer<CreateParticipantTokenRequest.Builder> createParticipantTokenRequest)

      Creates an additional token for a specified stage. This can be done after stage creation or when tokens expire. Tokens always are scoped to the stage for which they are created.

      Encryption keys are owned by Amazon IVS and never used directly by your application.


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

      Parameters:
      createParticipantTokenRequest - A Consumer that will call methods on CreateParticipantTokenRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateParticipantToken operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • ServiceQuotaExceededException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createStage

      default CompletableFuture<CreateStageResponse> createStage(CreateStageRequest createStageRequest)

      Creates a new stage (and optionally participant tokens).

      Parameters:
      createStageRequest -
      Returns:
      A Java Future containing the result of the CreateStage operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException
      • AccessDeniedException
      • ServiceQuotaExceededException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createStage

      default CompletableFuture<CreateStageResponse> createStage(Consumer<CreateStageRequest.Builder> createStageRequest)

      Creates a new stage (and optionally participant tokens).


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

      Parameters:
      createStageRequest - A Consumer that will call methods on CreateStageRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateStage operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException
      • AccessDeniedException
      • ServiceQuotaExceededException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createStorageConfiguration

      default CompletableFuture<CreateStorageConfigurationResponse> createStorageConfiguration(CreateStorageConfigurationRequest createStorageConfigurationRequest)

      Creates a new storage configuration, used to enable recording to Amazon S3. When a StorageConfiguration is created, IVS will modify the S3 bucketPolicy of the provided bucket. This will ensure that IVS has sufficient permissions to write content to the provided bucket.

      Parameters:
      createStorageConfigurationRequest -
      Returns:
      A Java Future containing the result of the CreateStorageConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createStorageConfiguration

      default CompletableFuture<CreateStorageConfigurationResponse> createStorageConfiguration(Consumer<CreateStorageConfigurationRequest.Builder> createStorageConfigurationRequest)

      Creates a new storage configuration, used to enable recording to Amazon S3. When a StorageConfiguration is created, IVS will modify the S3 bucketPolicy of the provided bucket. This will ensure that IVS has sufficient permissions to write content to the provided bucket.


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

      Parameters:
      createStorageConfigurationRequest - A Consumer that will call methods on CreateStorageConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateStorageConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteEncoderConfiguration

      default CompletableFuture<DeleteEncoderConfigurationResponse> deleteEncoderConfiguration(DeleteEncoderConfigurationRequest deleteEncoderConfigurationRequest)

      Deletes an EncoderConfiguration resource. Ensures that no Compositions are using this template; otherwise, returns an error.

      Parameters:
      deleteEncoderConfigurationRequest -
      Returns:
      A Java Future containing the result of the DeleteEncoderConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteEncoderConfiguration

      default CompletableFuture<DeleteEncoderConfigurationResponse> deleteEncoderConfiguration(Consumer<DeleteEncoderConfigurationRequest.Builder> deleteEncoderConfigurationRequest)

      Deletes an EncoderConfiguration resource. Ensures that no Compositions are using this template; otherwise, returns an error.


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

      Parameters:
      deleteEncoderConfigurationRequest - A Consumer that will call methods on DeleteEncoderConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteEncoderConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteIngestConfiguration

      default CompletableFuture<DeleteIngestConfigurationResponse> deleteIngestConfiguration(DeleteIngestConfigurationRequest deleteIngestConfigurationRequest)

      Deletes a specified IngestConfiguration, so it can no longer be used to broadcast. An IngestConfiguration cannot be deleted if the publisher is actively streaming to a stage, unless force is set to true.

      Parameters:
      deleteIngestConfigurationRequest -
      Returns:
      A Java Future containing the result of the DeleteIngestConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • ConflictException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteIngestConfiguration

      default CompletableFuture<DeleteIngestConfigurationResponse> deleteIngestConfiguration(Consumer<DeleteIngestConfigurationRequest.Builder> deleteIngestConfigurationRequest)

      Deletes a specified IngestConfiguration, so it can no longer be used to broadcast. An IngestConfiguration cannot be deleted if the publisher is actively streaming to a stage, unless force is set to true.


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

      Parameters:
      deleteIngestConfigurationRequest - A Consumer that will call methods on DeleteIngestConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteIngestConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • ConflictException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deletePublicKey

      default CompletableFuture<DeletePublicKeyResponse> deletePublicKey(DeletePublicKeyRequest deletePublicKeyRequest)

      Deletes the specified public key used to sign stage participant tokens. This invalidates future participant tokens generated using the key pair’s private key.

      Parameters:
      deletePublicKeyRequest -
      Returns:
      A Java Future containing the result of the DeletePublicKey operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • ConflictException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deletePublicKey

      default CompletableFuture<DeletePublicKeyResponse> deletePublicKey(Consumer<DeletePublicKeyRequest.Builder> deletePublicKeyRequest)

      Deletes the specified public key used to sign stage participant tokens. This invalidates future participant tokens generated using the key pair’s private key.


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

      Parameters:
      deletePublicKeyRequest - A Consumer that will call methods on DeletePublicKeyRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeletePublicKey operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • ConflictException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteStage

      default CompletableFuture<DeleteStageResponse> deleteStage(DeleteStageRequest deleteStageRequest)

      Shuts down and deletes the specified stage (disconnecting all participants). This operation also removes the stageArn from the associated IngestConfiguration, if there are participants using the IngestConfiguration to publish to the stage.

      Parameters:
      deleteStageRequest -
      Returns:
      A Java Future containing the result of the DeleteStage operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • ConflictException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteStage

      default CompletableFuture<DeleteStageResponse> deleteStage(Consumer<DeleteStageRequest.Builder> deleteStageRequest)

      Shuts down and deletes the specified stage (disconnecting all participants). This operation also removes the stageArn from the associated IngestConfiguration, if there are participants using the IngestConfiguration to publish to the stage.


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

      Parameters:
      deleteStageRequest - A Consumer that will call methods on DeleteStageRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteStage operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • ConflictException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteStorageConfiguration

      default CompletableFuture<DeleteStorageConfigurationResponse> deleteStorageConfiguration(DeleteStorageConfigurationRequest deleteStorageConfigurationRequest)

      Deletes the storage configuration for the specified ARN.

      If you try to delete a storage configuration that is used by a Composition, you will get an error (409 ConflictException). To avoid this, for all Compositions that reference the storage configuration, first use StopComposition and wait for it to complete, then use DeleteStorageConfiguration.

      Parameters:
      deleteStorageConfigurationRequest -
      Returns:
      A Java Future containing the result of the DeleteStorageConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteStorageConfiguration

      default CompletableFuture<DeleteStorageConfigurationResponse> deleteStorageConfiguration(Consumer<DeleteStorageConfigurationRequest.Builder> deleteStorageConfigurationRequest)

      Deletes the storage configuration for the specified ARN.

      If you try to delete a storage configuration that is used by a Composition, you will get an error (409 ConflictException). To avoid this, for all Compositions that reference the storage configuration, first use StopComposition and wait for it to complete, then use DeleteStorageConfiguration.


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

      Parameters:
      deleteStorageConfigurationRequest - A Consumer that will call methods on DeleteStorageConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteStorageConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • disconnectParticipant

      default CompletableFuture<DisconnectParticipantResponse> disconnectParticipant(DisconnectParticipantRequest disconnectParticipantRequest)

      Disconnects a specified participant from a specified stage. If the participant is publishing using an IngestConfiguration, DisconnectParticipant also updates the stageArn in the IngestConfiguration to be an empty string.

      Parameters:
      disconnectParticipantRequest -
      Returns:
      A Java Future containing the result of the DisconnectParticipant operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • disconnectParticipant

      default CompletableFuture<DisconnectParticipantResponse> disconnectParticipant(Consumer<DisconnectParticipantRequest.Builder> disconnectParticipantRequest)

      Disconnects a specified participant from a specified stage. If the participant is publishing using an IngestConfiguration, DisconnectParticipant also updates the stageArn in the IngestConfiguration to be an empty string.


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

      Parameters:
      disconnectParticipantRequest - A Consumer that will call methods on DisconnectParticipantRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DisconnectParticipant operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getComposition

      default CompletableFuture<GetCompositionResponse> getComposition(GetCompositionRequest getCompositionRequest)

      Get information about the specified Composition resource.

      Parameters:
      getCompositionRequest -
      Returns:
      A Java Future containing the result of the GetComposition operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getComposition

      default CompletableFuture<GetCompositionResponse> getComposition(Consumer<GetCompositionRequest.Builder> getCompositionRequest)

      Get information about the specified Composition resource.


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

      Parameters:
      getCompositionRequest - A Consumer that will call methods on GetCompositionRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetComposition operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getEncoderConfiguration

      default CompletableFuture<GetEncoderConfigurationResponse> getEncoderConfiguration(GetEncoderConfigurationRequest getEncoderConfigurationRequest)

      Gets information about the specified EncoderConfiguration resource.

      Parameters:
      getEncoderConfigurationRequest -
      Returns:
      A Java Future containing the result of the GetEncoderConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getEncoderConfiguration

      default CompletableFuture<GetEncoderConfigurationResponse> getEncoderConfiguration(Consumer<GetEncoderConfigurationRequest.Builder> getEncoderConfigurationRequest)

      Gets information about the specified EncoderConfiguration resource.


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

      Parameters:
      getEncoderConfigurationRequest - A Consumer that will call methods on GetEncoderConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetEncoderConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getIngestConfiguration

      default CompletableFuture<GetIngestConfigurationResponse> getIngestConfiguration(GetIngestConfigurationRequest getIngestConfigurationRequest)

      Gets information about the specified IngestConfiguration.

      Parameters:
      getIngestConfigurationRequest -
      Returns:
      A Java Future containing the result of the GetIngestConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getIngestConfiguration

      default CompletableFuture<GetIngestConfigurationResponse> getIngestConfiguration(Consumer<GetIngestConfigurationRequest.Builder> getIngestConfigurationRequest)

      Gets information about the specified IngestConfiguration.


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

      Parameters:
      getIngestConfigurationRequest - A Consumer that will call methods on GetIngestConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetIngestConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getParticipant

      default CompletableFuture<GetParticipantResponse> getParticipant(GetParticipantRequest getParticipantRequest)

      Gets information about the specified participant token.

      Parameters:
      getParticipantRequest -
      Returns:
      A Java Future containing the result of the GetParticipant operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getParticipant

      default CompletableFuture<GetParticipantResponse> getParticipant(Consumer<GetParticipantRequest.Builder> getParticipantRequest)

      Gets information about the specified participant token.


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

      Parameters:
      getParticipantRequest - A Consumer that will call methods on GetParticipantRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetParticipant operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getPublicKey

      default CompletableFuture<GetPublicKeyResponse> getPublicKey(GetPublicKeyRequest getPublicKeyRequest)

      Gets information for the specified public key.

      Parameters:
      getPublicKeyRequest -
      Returns:
      A Java Future containing the result of the GetPublicKey operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getPublicKey

      default CompletableFuture<GetPublicKeyResponse> getPublicKey(Consumer<GetPublicKeyRequest.Builder> getPublicKeyRequest)

      Gets information for the specified public key.


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

      Parameters:
      getPublicKeyRequest - A Consumer that will call methods on GetPublicKeyRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetPublicKey operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getStage

      default CompletableFuture<GetStageResponse> getStage(GetStageRequest getStageRequest)

      Gets information for the specified stage.

      Parameters:
      getStageRequest -
      Returns:
      A Java Future containing the result of the GetStage operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getStage

      default CompletableFuture<GetStageResponse> getStage(Consumer<GetStageRequest.Builder> getStageRequest)

      Gets information for the specified stage.


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

      Parameters:
      getStageRequest - A Consumer that will call methods on GetStageRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetStage operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getStageSession

      default CompletableFuture<GetStageSessionResponse> getStageSession(GetStageSessionRequest getStageSessionRequest)

      Gets information for the specified stage session.

      Parameters:
      getStageSessionRequest -
      Returns:
      A Java Future containing the result of the GetStageSession operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getStageSession

      default CompletableFuture<GetStageSessionResponse> getStageSession(Consumer<GetStageSessionRequest.Builder> getStageSessionRequest)

      Gets information for the specified stage session.


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

      Parameters:
      getStageSessionRequest - A Consumer that will call methods on GetStageSessionRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetStageSession operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getStorageConfiguration

      default CompletableFuture<GetStorageConfigurationResponse> getStorageConfiguration(GetStorageConfigurationRequest getStorageConfigurationRequest)

      Gets the storage configuration for the specified ARN.

      Parameters:
      getStorageConfigurationRequest -
      Returns:
      A Java Future containing the result of the GetStorageConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getStorageConfiguration

      default CompletableFuture<GetStorageConfigurationResponse> getStorageConfiguration(Consumer<GetStorageConfigurationRequest.Builder> getStorageConfigurationRequest)

      Gets the storage configuration for the specified ARN.


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

      Parameters:
      getStorageConfigurationRequest - A Consumer that will call methods on GetStorageConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetStorageConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • importPublicKey

      default CompletableFuture<ImportPublicKeyResponse> importPublicKey(ImportPublicKeyRequest importPublicKeyRequest)

      Import a public key to be used for signing stage participant tokens.

      Parameters:
      importPublicKeyRequest -
      Returns:
      A Java Future containing the result of the ImportPublicKey operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException
      • AccessDeniedException
      • ServiceQuotaExceededException
      • ConflictException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • importPublicKey

      default CompletableFuture<ImportPublicKeyResponse> importPublicKey(Consumer<ImportPublicKeyRequest.Builder> importPublicKeyRequest)

      Import a public key to be used for signing stage participant tokens.


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

      Parameters:
      importPublicKeyRequest - A Consumer that will call methods on ImportPublicKeyRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ImportPublicKey operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException
      • AccessDeniedException
      • ServiceQuotaExceededException
      • ConflictException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listCompositions

      default CompletableFuture<ListCompositionsResponse> listCompositions(ListCompositionsRequest listCompositionsRequest)

      Gets summary information about all Compositions in your account, in the AWS region where the API request is processed.

      Parameters:
      listCompositionsRequest -
      Returns:
      A Java Future containing the result of the ListCompositions operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listCompositions

      default CompletableFuture<ListCompositionsResponse> listCompositions(Consumer<ListCompositionsRequest.Builder> listCompositionsRequest)

      Gets summary information about all Compositions in your account, in the AWS region where the API request is processed.


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

      Parameters:
      listCompositionsRequest - A Consumer that will call methods on ListCompositionsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListCompositions operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listCompositionsPaginator

      default ListCompositionsPublisher listCompositionsPaginator(ListCompositionsRequest listCompositionsRequest)

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

      Parameters:
      listCompositionsRequest -
      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.
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listCompositionsPaginator

      default ListCompositionsPublisher listCompositionsPaginator(Consumer<ListCompositionsRequest.Builder> listCompositionsRequest)

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


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

      Parameters:
      listCompositionsRequest - A Consumer that will call methods on ListCompositionsRequest.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.
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listEncoderConfigurations

      default CompletableFuture<ListEncoderConfigurationsResponse> listEncoderConfigurations(ListEncoderConfigurationsRequest listEncoderConfigurationsRequest)

      Gets summary information about all EncoderConfigurations in your account, in the AWS region where the API request is processed.

      Parameters:
      listEncoderConfigurationsRequest -
      Returns:
      A Java Future containing the result of the ListEncoderConfigurations operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listEncoderConfigurations

      default CompletableFuture<ListEncoderConfigurationsResponse> listEncoderConfigurations(Consumer<ListEncoderConfigurationsRequest.Builder> listEncoderConfigurationsRequest)

      Gets summary information about all EncoderConfigurations in your account, in the AWS region where the API request is processed.


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

      Parameters:
      listEncoderConfigurationsRequest - A Consumer that will call methods on ListEncoderConfigurationsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListEncoderConfigurations operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listEncoderConfigurationsPaginator

      default ListEncoderConfigurationsPublisher listEncoderConfigurationsPaginator(ListEncoderConfigurationsRequest listEncoderConfigurationsRequest)

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

      Parameters:
      listEncoderConfigurationsRequest -
      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.
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listEncoderConfigurationsPaginator

      default ListEncoderConfigurationsPublisher listEncoderConfigurationsPaginator(Consumer<ListEncoderConfigurationsRequest.Builder> listEncoderConfigurationsRequest)

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


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

      Parameters:
      listEncoderConfigurationsRequest - A Consumer that will call methods on ListEncoderConfigurationsRequest.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.
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listIngestConfigurations

      default CompletableFuture<ListIngestConfigurationsResponse> listIngestConfigurations(ListIngestConfigurationsRequest listIngestConfigurationsRequest)

      Lists all IngestConfigurations in your account, in the AWS region where the API request is processed.

      Parameters:
      listIngestConfigurationsRequest -
      Returns:
      A Java Future containing the result of the ListIngestConfigurations operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listIngestConfigurations

      default CompletableFuture<ListIngestConfigurationsResponse> listIngestConfigurations(Consumer<ListIngestConfigurationsRequest.Builder> listIngestConfigurationsRequest)

      Lists all IngestConfigurations in your account, in the AWS region where the API request is processed.


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

      Parameters:
      listIngestConfigurationsRequest - A Consumer that will call methods on ListIngestConfigurationsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListIngestConfigurations operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listIngestConfigurationsPaginator

      default ListIngestConfigurationsPublisher listIngestConfigurationsPaginator(ListIngestConfigurationsRequest listIngestConfigurationsRequest)

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

      Parameters:
      listIngestConfigurationsRequest -
      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.
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listIngestConfigurationsPaginator

      default ListIngestConfigurationsPublisher listIngestConfigurationsPaginator(Consumer<ListIngestConfigurationsRequest.Builder> listIngestConfigurationsRequest)

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


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

      Parameters:
      listIngestConfigurationsRequest - A Consumer that will call methods on ListIngestConfigurationsRequest.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.
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listParticipantEvents

      default CompletableFuture<ListParticipantEventsResponse> listParticipantEvents(ListParticipantEventsRequest listParticipantEventsRequest)

      Lists events for a specified participant that occurred during a specified stage session.

      Parameters:
      listParticipantEventsRequest -
      Returns:
      A Java Future containing the result of the ListParticipantEvents operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listParticipantEvents

      default CompletableFuture<ListParticipantEventsResponse> listParticipantEvents(Consumer<ListParticipantEventsRequest.Builder> listParticipantEventsRequest)

      Lists events for a specified participant that occurred during a specified stage session.


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

      Parameters:
      listParticipantEventsRequest - A Consumer that will call methods on ListParticipantEventsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListParticipantEvents operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listParticipantEventsPaginator

      default ListParticipantEventsPublisher listParticipantEventsPaginator(ListParticipantEventsRequest listParticipantEventsRequest)

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

      Parameters:
      listParticipantEventsRequest -
      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.
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listParticipantEventsPaginator

      default ListParticipantEventsPublisher listParticipantEventsPaginator(Consumer<ListParticipantEventsRequest.Builder> listParticipantEventsRequest)

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


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

      Parameters:
      listParticipantEventsRequest - A Consumer that will call methods on ListParticipantEventsRequest.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.
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listParticipantReplicas

      default CompletableFuture<ListParticipantReplicasResponse> listParticipantReplicas(ListParticipantReplicasRequest listParticipantReplicasRequest)

      Lists all the replicas for a participant from a source stage.

      Parameters:
      listParticipantReplicasRequest -
      Returns:
      A Java Future containing the result of the ListParticipantReplicas operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listParticipantReplicas

      default CompletableFuture<ListParticipantReplicasResponse> listParticipantReplicas(Consumer<ListParticipantReplicasRequest.Builder> listParticipantReplicasRequest)

      Lists all the replicas for a participant from a source stage.


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

      Parameters:
      listParticipantReplicasRequest - A Consumer that will call methods on ListParticipantReplicasRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListParticipantReplicas operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listParticipantReplicasPaginator

      default ListParticipantReplicasPublisher listParticipantReplicasPaginator(ListParticipantReplicasRequest listParticipantReplicasRequest)

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

      Parameters:
      listParticipantReplicasRequest -
      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.
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listParticipantReplicasPaginator

      default ListParticipantReplicasPublisher listParticipantReplicasPaginator(Consumer<ListParticipantReplicasRequest.Builder> listParticipantReplicasRequest)

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


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

      Parameters:
      listParticipantReplicasRequest - A Consumer that will call methods on ListParticipantReplicasRequest.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.
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listParticipants

      default CompletableFuture<ListParticipantsResponse> listParticipants(ListParticipantsRequest listParticipantsRequest)

      Lists all participants in a specified stage session.

      Parameters:
      listParticipantsRequest -
      Returns:
      A Java Future containing the result of the ListParticipants operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listParticipants

      default CompletableFuture<ListParticipantsResponse> listParticipants(Consumer<ListParticipantsRequest.Builder> listParticipantsRequest)

      Lists all participants in a specified stage session.


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

      Parameters:
      listParticipantsRequest - A Consumer that will call methods on ListParticipantsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListParticipants operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listParticipantsPaginator

      default ListParticipantsPublisher listParticipantsPaginator(ListParticipantsRequest listParticipantsRequest)

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

      Parameters:
      listParticipantsRequest -
      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.
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listParticipantsPaginator

      default ListParticipantsPublisher listParticipantsPaginator(Consumer<ListParticipantsRequest.Builder> listParticipantsRequest)

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


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

      Parameters:
      listParticipantsRequest - A Consumer that will call methods on ListParticipantsRequest.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.
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listPublicKeys

      default CompletableFuture<ListPublicKeysResponse> listPublicKeys(ListPublicKeysRequest listPublicKeysRequest)

      Gets summary information about all public keys in your account, in the AWS region where the API request is processed.

      Parameters:
      listPublicKeysRequest -
      Returns:
      A Java Future containing the result of the ListPublicKeys operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listPublicKeys

      default CompletableFuture<ListPublicKeysResponse> listPublicKeys(Consumer<ListPublicKeysRequest.Builder> listPublicKeysRequest)

      Gets summary information about all public keys in your account, in the AWS region where the API request is processed.


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

      Parameters:
      listPublicKeysRequest - A Consumer that will call methods on ListPublicKeysRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListPublicKeys operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listPublicKeysPaginator

      default ListPublicKeysPublisher listPublicKeysPaginator(ListPublicKeysRequest listPublicKeysRequest)

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

      Parameters:
      listPublicKeysRequest -
      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.
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listPublicKeysPaginator

      default ListPublicKeysPublisher listPublicKeysPaginator(Consumer<ListPublicKeysRequest.Builder> listPublicKeysRequest)

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


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

      Parameters:
      listPublicKeysRequest - A Consumer that will call methods on ListPublicKeysRequest.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.
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listStageSessions

      default CompletableFuture<ListStageSessionsResponse> listStageSessions(ListStageSessionsRequest listStageSessionsRequest)

      Gets all sessions for a specified stage.

      Parameters:
      listStageSessionsRequest -
      Returns:
      A Java Future containing the result of the ListStageSessions operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listStageSessions

      default CompletableFuture<ListStageSessionsResponse> listStageSessions(Consumer<ListStageSessionsRequest.Builder> listStageSessionsRequest)

      Gets all sessions for a specified stage.


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

      Parameters:
      listStageSessionsRequest - A Consumer that will call methods on ListStageSessionsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListStageSessions operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listStageSessionsPaginator

      default ListStageSessionsPublisher listStageSessionsPaginator(ListStageSessionsRequest listStageSessionsRequest)

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

      Parameters:
      listStageSessionsRequest -
      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.
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listStageSessionsPaginator

      default ListStageSessionsPublisher listStageSessionsPaginator(Consumer<ListStageSessionsRequest.Builder> listStageSessionsRequest)

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


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

      Parameters:
      listStageSessionsRequest - A Consumer that will call methods on ListStageSessionsRequest.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.
      • ValidationException
      • AccessDeniedException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listStages

      default CompletableFuture<ListStagesResponse> listStages(ListStagesRequest listStagesRequest)

      Gets summary information about all stages in your account, in the AWS region where the API request is processed.

      Parameters:
      listStagesRequest -
      Returns:
      A Java Future containing the result of the ListStages operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException
      • AccessDeniedException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listStages

      default CompletableFuture<ListStagesResponse> listStages(Consumer<ListStagesRequest.Builder> listStagesRequest)

      Gets summary information about all stages in your account, in the AWS region where the API request is processed.


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

      Parameters:
      listStagesRequest - A Consumer that will call methods on ListStagesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListStages operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException
      • AccessDeniedException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listStagesPaginator

      default ListStagesPublisher listStagesPaginator(ListStagesRequest listStagesRequest)

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

      Parameters:
      listStagesRequest -
      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.
      • ValidationException
      • AccessDeniedException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listStagesPaginator

      default ListStagesPublisher listStagesPaginator(Consumer<ListStagesRequest.Builder> listStagesRequest)

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


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

      Parameters:
      listStagesRequest - A Consumer that will call methods on ListStagesRequest.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.
      • ValidationException
      • AccessDeniedException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listStorageConfigurations

      default CompletableFuture<ListStorageConfigurationsResponse> listStorageConfigurations(ListStorageConfigurationsRequest listStorageConfigurationsRequest)

      Gets summary information about all storage configurations in your account, in the AWS region where the API request is processed.

      Parameters:
      listStorageConfigurationsRequest -
      Returns:
      A Java Future containing the result of the ListStorageConfigurations operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listStorageConfigurations

      default CompletableFuture<ListStorageConfigurationsResponse> listStorageConfigurations(Consumer<ListStorageConfigurationsRequest.Builder> listStorageConfigurationsRequest)

      Gets summary information about all storage configurations in your account, in the AWS region where the API request is processed.


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

      Parameters:
      listStorageConfigurationsRequest - A Consumer that will call methods on ListStorageConfigurationsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListStorageConfigurations operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listStorageConfigurationsPaginator

      default ListStorageConfigurationsPublisher listStorageConfigurationsPaginator(ListStorageConfigurationsRequest listStorageConfigurationsRequest)

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

      Parameters:
      listStorageConfigurationsRequest -
      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.
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listStorageConfigurationsPaginator

      default ListStorageConfigurationsPublisher listStorageConfigurationsPaginator(Consumer<ListStorageConfigurationsRequest.Builder> listStorageConfigurationsRequest)

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


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

      Parameters:
      listStorageConfigurationsRequest - A Consumer that will call methods on ListStorageConfigurationsRequest.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.
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException 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)

      Gets information about AWS tags for the specified ARN.

      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.
      • ResourceNotFoundException
      • ValidationException
      • InternalServerException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException 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)

      Gets information about AWS tags for the specified ARN.


      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.
      • ResourceNotFoundException
      • ValidationException
      • InternalServerException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • startComposition

      default CompletableFuture<StartCompositionResponse> startComposition(StartCompositionRequest startCompositionRequest)

      Starts a Composition from a stage based on the configuration provided in the request.

      A Composition is an ephemeral resource that exists after this operation returns successfully. Composition stops and the resource is deleted:

      • When StopComposition is called.

      • After a 1-minute timeout, when all participants are disconnected from the stage.

      • After a 1-minute timeout, if there are no participants in the stage when StartComposition is called.

      • When broadcasting to the IVS channel fails and all retries are exhausted.

      • When broadcasting is disconnected and all attempts to reconnect are exhausted.

      Parameters:
      startCompositionRequest -
      Returns:
      A Java Future containing the result of the StartComposition operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • startComposition

      default CompletableFuture<StartCompositionResponse> startComposition(Consumer<StartCompositionRequest.Builder> startCompositionRequest)

      Starts a Composition from a stage based on the configuration provided in the request.

      A Composition is an ephemeral resource that exists after this operation returns successfully. Composition stops and the resource is deleted:

      • When StopComposition is called.

      • After a 1-minute timeout, when all participants are disconnected from the stage.

      • After a 1-minute timeout, if there are no participants in the stage when StartComposition is called.

      • When broadcasting to the IVS channel fails and all retries are exhausted.

      • When broadcasting is disconnected and all attempts to reconnect are exhausted.


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

      Parameters:
      startCompositionRequest - A Consumer that will call methods on StartCompositionRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the StartComposition operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • startParticipantReplication

      default CompletableFuture<StartParticipantReplicationResponse> startParticipantReplication(StartParticipantReplicationRequest startParticipantReplicationRequest)

      Starts replicating a publishing participant from a source stage to a destination stage.

      Parameters:
      startParticipantReplicationRequest -
      Returns:
      A Java Future containing the result of the StartParticipantReplication operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • startParticipantReplication

      default CompletableFuture<StartParticipantReplicationResponse> startParticipantReplication(Consumer<StartParticipantReplicationRequest.Builder> startParticipantReplicationRequest)

      Starts replicating a publishing participant from a source stage to a destination stage.


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

      Parameters:
      startParticipantReplicationRequest - A Consumer that will call methods on StartParticipantReplicationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the StartParticipantReplication operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • stopComposition

      default CompletableFuture<StopCompositionResponse> stopComposition(StopCompositionRequest stopCompositionRequest)

      Stops and deletes a Composition resource. Any broadcast from the Composition resource is stopped.

      Parameters:
      stopCompositionRequest -
      Returns:
      A Java Future containing the result of the StopComposition operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • stopComposition

      default CompletableFuture<StopCompositionResponse> stopComposition(Consumer<StopCompositionRequest.Builder> stopCompositionRequest)

      Stops and deletes a Composition resource. Any broadcast from the Composition resource is stopped.


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

      Parameters:
      stopCompositionRequest - A Consumer that will call methods on StopCompositionRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the StopComposition operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • ServiceQuotaExceededException
      • ConflictException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • stopParticipantReplication

      default CompletableFuture<StopParticipantReplicationResponse> stopParticipantReplication(StopParticipantReplicationRequest stopParticipantReplicationRequest)

      Stops a replicated participant session.

      Parameters:
      stopParticipantReplicationRequest -
      Returns:
      A Java Future containing the result of the StopParticipantReplication operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • stopParticipantReplication

      default CompletableFuture<StopParticipantReplicationResponse> stopParticipantReplication(Consumer<StopParticipantReplicationRequest.Builder> stopParticipantReplicationRequest)

      Stops a replicated participant session.


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

      Parameters:
      stopParticipantReplicationRequest - A Consumer that will call methods on StopParticipantReplicationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the StopParticipantReplication operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • InternalServerException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException 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)

      Adds or updates tags for the AWS resource with the specified ARN.

      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.
      • ResourceNotFoundException
      • ValidationException
      • InternalServerException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException 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)

      Adds or updates tags for the AWS resource with the specified ARN.


      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.
      • ResourceNotFoundException
      • ValidationException
      • InternalServerException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException 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 tags from the resource with the specified ARN.

      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.
      • ResourceNotFoundException
      • ValidationException
      • InternalServerException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException 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 tags from the resource with the specified ARN.


      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.
      • ResourceNotFoundException
      • ValidationException
      • InternalServerException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateIngestConfiguration

      default CompletableFuture<UpdateIngestConfigurationResponse> updateIngestConfiguration(UpdateIngestConfigurationRequest updateIngestConfigurationRequest)

      Updates a specified IngestConfiguration. Only the stage ARN attached to the IngestConfiguration can be updated. An IngestConfiguration that is active cannot be updated.

      Parameters:
      updateIngestConfigurationRequest -
      Returns:
      A Java Future containing the result of the UpdateIngestConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • ConflictException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateIngestConfiguration

      default CompletableFuture<UpdateIngestConfigurationResponse> updateIngestConfiguration(Consumer<UpdateIngestConfigurationRequest.Builder> updateIngestConfigurationRequest)

      Updates a specified IngestConfiguration. Only the stage ARN attached to the IngestConfiguration can be updated. An IngestConfiguration that is active cannot be updated.


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

      Parameters:
      updateIngestConfigurationRequest - A Consumer that will call methods on UpdateIngestConfigurationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateIngestConfiguration operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • ConflictException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateStage

      default CompletableFuture<UpdateStageResponse> updateStage(UpdateStageRequest updateStageRequest)

      Updates a stage’s configuration.

      Parameters:
      updateStageRequest -
      Returns:
      A Java Future containing the result of the UpdateStage operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • ServiceQuotaExceededException
      • ConflictException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateStage

      default CompletableFuture<UpdateStageResponse> updateStage(Consumer<UpdateStageRequest.Builder> updateStageRequest)

      Updates a stage’s configuration.


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

      Parameters:
      updateStageRequest - A Consumer that will call methods on UpdateStageRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateStage operation returned by the service.
      The CompletableFuture returned by this method can be completed 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
      • ValidationException
      • AccessDeniedException
      • ServiceQuotaExceededException
      • ConflictException
      • PendingVerificationException
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • IvsRealTimeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • serviceClientConfiguration

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

    • builder

      static IvsRealTimeAsyncClientBuilder builder()
      Create a builder that can be used to configure and create a IvsRealTimeAsyncClient.