Interface Resiliencehubv2AsyncClient

All Superinterfaces:
AutoCloseable, AwsClient, SdkAutoCloseable, SdkClient
@Generated("software.amazon.awssdk:codegen") @SdkPublicApi @ThreadSafe public interface Resiliencehubv2AsyncClient extends AwsClient
Service client for accessing AWS Resilience Hub V2 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 next generation of AWS Resilience Hub is the single location in AWS where you assess and improve the resilience of your critical applications. It helps Site Reliability Engineers (SREs) and development teams proactively reason about resilience at scale — identifying failure modes, discovering hidden dependencies, and report on progress across the enterprise.

  • Field Details

  • Method Details

    • createAssertion

      default CompletableFuture<CreateAssertionResponse> createAssertion(CreateAssertionRequest createAssertionRequest)

      Creates a resilience assertion for a service.

      Parameters:
      createAssertionRequest -
      Returns:
      A Java Future containing the result of the CreateAssertion operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • ServiceQuotaExceededException Service quota exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createAssertion

      default CompletableFuture<CreateAssertionResponse> createAssertion(Consumer<CreateAssertionRequest.Builder> createAssertionRequest)

      Creates a resilience assertion for a service.


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

      Parameters:
      createAssertionRequest - A Consumer that will call methods on CreateAssertionRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateAssertion operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • ServiceQuotaExceededException Service quota exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createInputSource

      default CompletableFuture<CreateInputSourceResponse> createInputSource(CreateInputSourceRequest createInputSourceRequest)

      Creates an input source for a service.

      Parameters:
      createInputSourceRequest -
      Returns:
      A Java Future containing the result of the CreateInputSource operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • ServiceQuotaExceededException Service quota exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createInputSource

      default CompletableFuture<CreateInputSourceResponse> createInputSource(Consumer<CreateInputSourceRequest.Builder> createInputSourceRequest)

      Creates an input source for a service.


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

      Parameters:
      createInputSourceRequest - A Consumer that will call methods on CreateInputSourceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateInputSource operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • ServiceQuotaExceededException Service quota exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createPolicy

      default CompletableFuture<CreatePolicyResponse> createPolicy(CreatePolicyRequest createPolicyRequest)

      Creates a resilience policy that defines availability and disaster recovery requirements.

      Parameters:
      createPolicyRequest -
      Returns:
      A Java Future containing the result of the CreatePolicy operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • ServiceQuotaExceededException Service quota exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createPolicy

      default CompletableFuture<CreatePolicyResponse> createPolicy(Consumer<CreatePolicyRequest.Builder> createPolicyRequest)

      Creates a resilience policy that defines availability and disaster recovery requirements.


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

      Parameters:
      createPolicyRequest - A Consumer that will call methods on CreatePolicyRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreatePolicy operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • ServiceQuotaExceededException Service quota exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createReport

      default CompletableFuture<CreateReportResponse> createReport(CreateReportRequest createReportRequest)

      On-demand report creation. Idempotent — duplicate requests with same clientToken return existing result.

      Parameters:
      createReportRequest -
      Returns:
      A Java Future containing the result of the CreateReport operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • ThrottlingException Too many requests — rate limit exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createReport

      default CompletableFuture<CreateReportResponse> createReport(Consumer<CreateReportRequest.Builder> createReportRequest)

      On-demand report creation. Idempotent — duplicate requests with same clientToken return existing result.


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

      Parameters:
      createReportRequest - A Consumer that will call methods on CreateReportRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateReport operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • ThrottlingException Too many requests — rate limit exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createService

      default CompletableFuture<CreateServiceResponse> createService(CreateServiceRequest createServiceRequest)

      Creates a service.

      Parameters:
      createServiceRequest -
      Returns:
      A Java Future containing the result of the CreateService operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • ServiceQuotaExceededException Service quota exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createService

      default CompletableFuture<CreateServiceResponse> createService(Consumer<CreateServiceRequest.Builder> createServiceRequest)

      Creates a service.


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

      Parameters:
      createServiceRequest - A Consumer that will call methods on CreateServiceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateService operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • ServiceQuotaExceededException Service quota exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createServiceFunction

      default CompletableFuture<CreateServiceFunctionResponse> createServiceFunction(CreateServiceFunctionRequest createServiceFunctionRequest)

      Creates a service function within a service.

      Parameters:
      createServiceFunctionRequest -
      Returns:
      A Java Future containing the result of the CreateServiceFunction operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • ServiceQuotaExceededException Service quota exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createServiceFunction

      default CompletableFuture<CreateServiceFunctionResponse> createServiceFunction(Consumer<CreateServiceFunctionRequest.Builder> createServiceFunctionRequest)

      Creates a service function within a service.


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

      Parameters:
      createServiceFunctionRequest - A Consumer that will call methods on CreateServiceFunctionRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateServiceFunction operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • ServiceQuotaExceededException Service quota exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createServiceFunctionResources

      default CompletableFuture<CreateServiceFunctionResourcesResponse> createServiceFunctionResources(CreateServiceFunctionResourcesRequest createServiceFunctionResourcesRequest)

      Associates resources with a service function.

      Parameters:
      createServiceFunctionResourcesRequest -
      Returns:
      A Java Future containing the result of the CreateServiceFunctionResources operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createServiceFunctionResources

      default CompletableFuture<CreateServiceFunctionResourcesResponse> createServiceFunctionResources(Consumer<CreateServiceFunctionResourcesRequest.Builder> createServiceFunctionResourcesRequest)

      Associates resources with a service function.


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

      Parameters:
      createServiceFunctionResourcesRequest - A Consumer that will call methods on CreateServiceFunctionResourcesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateServiceFunctionResources operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createSystem

      default CompletableFuture<CreateSystemResponse> createSystem(CreateSystemRequest createSystemRequest)

      Creates a system that represents a logical grouping of services.

      Parameters:
      createSystemRequest -
      Returns:
      A Java Future containing the result of the CreateSystem operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • ServiceQuotaExceededException Service quota exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createSystem

      default CompletableFuture<CreateSystemResponse> createSystem(Consumer<CreateSystemRequest.Builder> createSystemRequest)

      Creates a system that represents a logical grouping of services.


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

      Parameters:
      createSystemRequest - A Consumer that will call methods on CreateSystemRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateSystem operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • ServiceQuotaExceededException Service quota exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createTest

      default CompletableFuture<CreateTestResponse> createTest(CreateTestRequest createTestRequest)

      Creates a test for a service by configuring a test template. Each service has one test per template.

      Parameters:
      createTestRequest -
      Returns:
      A Java Future containing the result of the CreateTest operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createTest

      default CompletableFuture<CreateTestResponse> createTest(Consumer<CreateTestRequest.Builder> createTestRequest)

      Creates a test for a service by configuring a test template. Each service has one test per template.


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

      Parameters:
      createTestRequest - A Consumer that will call methods on CreateTestRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateTest operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createUserJourney

      default CompletableFuture<CreateUserJourneyResponse> createUserJourney(CreateUserJourneyRequest createUserJourneyRequest)

      Creates a user journey within a system.

      Parameters:
      createUserJourneyRequest -
      Returns:
      A Java Future containing the result of the CreateUserJourney operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • ServiceQuotaExceededException Service quota exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createUserJourney

      default CompletableFuture<CreateUserJourneyResponse> createUserJourney(Consumer<CreateUserJourneyRequest.Builder> createUserJourneyRequest)

      Creates a user journey within a system.


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

      Parameters:
      createUserJourneyRequest - A Consumer that will call methods on CreateUserJourneyRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateUserJourney operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • ServiceQuotaExceededException Service quota exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteAssertion

      default CompletableFuture<DeleteAssertionResponse> deleteAssertion(DeleteAssertionRequest deleteAssertionRequest)

      Deletes a resilience assertion from a service.

      Parameters:
      deleteAssertionRequest -
      Returns:
      A Java Future containing the result of the DeleteAssertion operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteAssertion

      default CompletableFuture<DeleteAssertionResponse> deleteAssertion(Consumer<DeleteAssertionRequest.Builder> deleteAssertionRequest)

      Deletes a resilience assertion from a service.


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

      Parameters:
      deleteAssertionRequest - A Consumer that will call methods on DeleteAssertionRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteAssertion operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteInputSource

      default CompletableFuture<DeleteInputSourceResponse> deleteInputSource(DeleteInputSourceRequest deleteInputSourceRequest)

      Deletes an input source.

      Parameters:
      deleteInputSourceRequest -
      Returns:
      A Java Future containing the result of the DeleteInputSource operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteInputSource

      default CompletableFuture<DeleteInputSourceResponse> deleteInputSource(Consumer<DeleteInputSourceRequest.Builder> deleteInputSourceRequest)

      Deletes an input source.


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

      Parameters:
      deleteInputSourceRequest - A Consumer that will call methods on DeleteInputSourceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteInputSource operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deletePolicy

      default CompletableFuture<DeletePolicyResponse> deletePolicy(DeletePolicyRequest deletePolicyRequest)

      Deletes a resilience policy.

      Parameters:
      deletePolicyRequest -
      Returns:
      A Java Future containing the result of the DeletePolicy operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deletePolicy

      default CompletableFuture<DeletePolicyResponse> deletePolicy(Consumer<DeletePolicyRequest.Builder> deletePolicyRequest)

      Deletes a resilience policy.


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

      Parameters:
      deletePolicyRequest - A Consumer that will call methods on DeletePolicyRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeletePolicy operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteService

      default CompletableFuture<DeleteServiceResponse> deleteService(DeleteServiceRequest deleteServiceRequest)

      Deletes a service.

      Parameters:
      deleteServiceRequest -
      Returns:
      A Java Future containing the result of the DeleteService operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteService

      default CompletableFuture<DeleteServiceResponse> deleteService(Consumer<DeleteServiceRequest.Builder> deleteServiceRequest)

      Deletes a service.


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

      Parameters:
      deleteServiceRequest - A Consumer that will call methods on DeleteServiceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteService operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteServiceFunction

      default CompletableFuture<DeleteServiceFunctionResponse> deleteServiceFunction(DeleteServiceFunctionRequest deleteServiceFunctionRequest)

      Deletes a service function.

      Parameters:
      deleteServiceFunctionRequest -
      Returns:
      A Java Future containing the result of the DeleteServiceFunction operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteServiceFunction

      default CompletableFuture<DeleteServiceFunctionResponse> deleteServiceFunction(Consumer<DeleteServiceFunctionRequest.Builder> deleteServiceFunctionRequest)

      Deletes a service function.


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

      Parameters:
      deleteServiceFunctionRequest - A Consumer that will call methods on DeleteServiceFunctionRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteServiceFunction operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteServiceFunctionResources

      default CompletableFuture<DeleteServiceFunctionResourcesResponse> deleteServiceFunctionResources(DeleteServiceFunctionResourcesRequest deleteServiceFunctionResourcesRequest)

      Removes resources from a service function.

      Parameters:
      deleteServiceFunctionResourcesRequest -
      Returns:
      A Java Future containing the result of the DeleteServiceFunctionResources operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteServiceFunctionResources

      default CompletableFuture<DeleteServiceFunctionResourcesResponse> deleteServiceFunctionResources(Consumer<DeleteServiceFunctionResourcesRequest.Builder> deleteServiceFunctionResourcesRequest)

      Removes resources from a service function.


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

      Parameters:
      deleteServiceFunctionResourcesRequest - A Consumer that will call methods on DeleteServiceFunctionResourcesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteServiceFunctionResources operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteSystem

      default CompletableFuture<DeleteSystemResponse> deleteSystem(DeleteSystemRequest deleteSystemRequest)

      Deletes a system.

      Parameters:
      deleteSystemRequest -
      Returns:
      A Java Future containing the result of the DeleteSystem operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteSystem

      default CompletableFuture<DeleteSystemResponse> deleteSystem(Consumer<DeleteSystemRequest.Builder> deleteSystemRequest)

      Deletes a system.


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

      Parameters:
      deleteSystemRequest - A Consumer that will call methods on DeleteSystemRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteSystem operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteTest

      default CompletableFuture<DeleteTestResponse> deleteTest(DeleteTestRequest deleteTestRequest)

      Deletes a test.

      Parameters:
      deleteTestRequest -
      Returns:
      A Java Future containing the result of the DeleteTest operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteTest

      default CompletableFuture<DeleteTestResponse> deleteTest(Consumer<DeleteTestRequest.Builder> deleteTestRequest)

      Deletes a test.


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

      Parameters:
      deleteTestRequest - A Consumer that will call methods on DeleteTestRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteTest operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteTestSources

      default CompletableFuture<DeleteTestSourcesResponse> deleteTestSources(DeleteTestSourcesRequest deleteTestSourcesRequest)

      Removes monitoring sources from a test. The operation is transactional and idempotent — removing a source that is not attached is a no-op.

      Parameters:
      deleteTestSourcesRequest -
      Returns:
      A Java Future containing the result of the DeleteTestSources operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteTestSources

      default CompletableFuture<DeleteTestSourcesResponse> deleteTestSources(Consumer<DeleteTestSourcesRequest.Builder> deleteTestSourcesRequest)

      Removes monitoring sources from a test. The operation is transactional and idempotent — removing a source that is not attached is a no-op.


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

      Parameters:
      deleteTestSourcesRequest - A Consumer that will call methods on DeleteTestSourcesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteTestSources operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteUserJourney

      default CompletableFuture<DeleteUserJourneyResponse> deleteUserJourney(DeleteUserJourneyRequest deleteUserJourneyRequest)

      Deletes a user journey.

      Parameters:
      deleteUserJourneyRequest -
      Returns:
      A Java Future containing the result of the DeleteUserJourney operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteUserJourney

      default CompletableFuture<DeleteUserJourneyResponse> deleteUserJourney(Consumer<DeleteUserJourneyRequest.Builder> deleteUserJourneyRequest)

      Deletes a user journey.


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

      Parameters:
      deleteUserJourneyRequest - A Consumer that will call methods on DeleteUserJourneyRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteUserJourney operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getFailureModeFinding

      default CompletableFuture<GetFailureModeFindingResponse> getFailureModeFinding(GetFailureModeFindingRequest getFailureModeFindingRequest)

      Retrieves a finding by findingId.

      Parameters:
      getFailureModeFindingRequest -
      Returns:
      A Java Future containing the result of the GetFailureModeFinding operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getFailureModeFinding

      default CompletableFuture<GetFailureModeFindingResponse> getFailureModeFinding(Consumer<GetFailureModeFindingRequest.Builder> getFailureModeFindingRequest)

      Retrieves a finding by findingId.


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

      Parameters:
      getFailureModeFindingRequest - A Consumer that will call methods on GetFailureModeFindingRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetFailureModeFinding operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getPolicy

      default CompletableFuture<GetPolicyResponse> getPolicy(GetPolicyRequest getPolicyRequest)

      Retrieves a resilience policy by ARN.

      Parameters:
      getPolicyRequest -
      Returns:
      A Java Future containing the result of the GetPolicy operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getPolicy

      default CompletableFuture<GetPolicyResponse> getPolicy(Consumer<GetPolicyRequest.Builder> getPolicyRequest)

      Retrieves a resilience policy by ARN.


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

      Parameters:
      getPolicyRequest - A Consumer that will call methods on GetPolicyRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetPolicy operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getService

      default CompletableFuture<GetServiceResponse> getService(GetServiceRequest getServiceRequest)

      Retrieves a service by ARN.

      Parameters:
      getServiceRequest -
      Returns:
      A Java Future containing the result of the GetService operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getService

      default CompletableFuture<GetServiceResponse> getService(Consumer<GetServiceRequest.Builder> getServiceRequest)

      Retrieves a service by ARN.


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

      Parameters:
      getServiceRequest - A Consumer that will call methods on GetServiceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetService operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getSystem

      default CompletableFuture<GetSystemResponse> getSystem(GetSystemRequest getSystemRequest)

      Retrieves a system by ARN.

      Parameters:
      getSystemRequest -
      Returns:
      A Java Future containing the result of the GetSystem operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getSystem

      default CompletableFuture<GetSystemResponse> getSystem(Consumer<GetSystemRequest.Builder> getSystemRequest)

      Retrieves a system by ARN.


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

      Parameters:
      getSystemRequest - A Consumer that will call methods on GetSystemRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetSystem operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getTest

      default CompletableFuture<GetTestResponse> getTest(GetTestRequest getTestRequest)

      Retrieves a test by ID.

      Parameters:
      getTestRequest -
      Returns:
      A Java Future containing the result of the GetTest operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getTest

      default CompletableFuture<GetTestResponse> getTest(Consumer<GetTestRequest.Builder> getTestRequest)

      Retrieves a test by ID.


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

      Parameters:
      getTestRequest - A Consumer that will call methods on GetTestRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetTest operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getTestRun

      default CompletableFuture<GetTestRunResponse> getTestRun(GetTestRunRequest getTestRunRequest)

      Retrieves a test run by ID, including its status, results, and the configuration snapshotted when the run started.

      Parameters:
      getTestRunRequest -
      Returns:
      A Java Future containing the result of the GetTestRun operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getTestRun

      default CompletableFuture<GetTestRunResponse> getTestRun(Consumer<GetTestRunRequest.Builder> getTestRunRequest)

      Retrieves a test run by ID, including its status, results, and the configuration snapshotted when the run started.


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

      Parameters:
      getTestRunRequest - A Consumer that will call methods on GetTestRunRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetTestRun operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getTestTemplate

      default CompletableFuture<GetTestTemplateResponse> getTestTemplate(GetTestTemplateRequest getTestTemplateRequest)

      Retrieves a resilience test template by ARN, including the parameters it accepts and the fault actions it runs.

      Parameters:
      getTestTemplateRequest -
      Returns:
      A Java Future containing the result of the GetTestTemplate operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getTestTemplate

      default CompletableFuture<GetTestTemplateResponse> getTestTemplate(Consumer<GetTestTemplateRequest.Builder> getTestTemplateRequest)

      Retrieves a resilience test template by ARN, including the parameters it accepts and the fault actions it runs.


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

      Parameters:
      getTestTemplateRequest - A Consumer that will call methods on GetTestTemplateRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetTestTemplate operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getUserJourney

      default CompletableFuture<GetUserJourneyResponse> getUserJourney(GetUserJourneyRequest getUserJourneyRequest)

      Retrieves a user journey.

      Parameters:
      getUserJourneyRequest -
      Returns:
      A Java Future containing the result of the GetUserJourney operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getUserJourney

      default CompletableFuture<GetUserJourneyResponse> getUserJourney(Consumer<GetUserJourneyRequest.Builder> getUserJourneyRequest)

      Retrieves a user journey.


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

      Parameters:
      getUserJourneyRequest - A Consumer that will call methods on GetUserJourneyRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetUserJourney operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • importApp

      default CompletableFuture<ImportAppResponse> importApp(ImportAppRequest importAppRequest)

      Imports a V1 app into the V2 resource model, creating a service with the same name.

      Parameters:
      importAppRequest -
      Returns:
      A Java Future containing the result of the ImportApp operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • importApp

      default CompletableFuture<ImportAppResponse> importApp(Consumer<ImportAppRequest.Builder> importAppRequest)

      Imports a V1 app into the V2 resource model, creating a service with the same name.


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

      Parameters:
      importAppRequest - A Consumer that will call methods on ImportAppRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ImportApp operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • importPolicy

      default CompletableFuture<ImportPolicyResponse> importPolicy(ImportPolicyRequest importPolicyRequest)

      Imports a V1 policy into V2, mapping RTO/RPO values from V1 scenarios.

      Parameters:
      importPolicyRequest -
      Returns:
      A Java Future containing the result of the ImportPolicy operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • importPolicy

      default CompletableFuture<ImportPolicyResponse> importPolicy(Consumer<ImportPolicyRequest.Builder> importPolicyRequest)

      Imports a V1 policy into V2, mapping RTO/RPO values from V1 scenarios.


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

      Parameters:
      importPolicyRequest - A Consumer that will call methods on ImportPolicyRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ImportPolicy operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listAssertions

      default CompletableFuture<ListAssertionsResponse> listAssertions(ListAssertionsRequest listAssertionsRequest)

      Lists resilience assertions for a service.

      Parameters:
      listAssertionsRequest -
      Returns:
      A Java Future containing the result of the ListAssertions operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listAssertions

      default CompletableFuture<ListAssertionsResponse> listAssertions(Consumer<ListAssertionsRequest.Builder> listAssertionsRequest)

      Lists resilience assertions for a service.


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

      Parameters:
      listAssertionsRequest - A Consumer that will call methods on ListAssertionsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListAssertions operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listAssertionsPaginator

      default ListAssertionsPublisher listAssertionsPaginator(ListAssertionsRequest listAssertionsRequest)

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

      Parameters:
      listAssertionsRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listAssertionsPaginator

      default ListAssertionsPublisher listAssertionsPaginator(Consumer<ListAssertionsRequest.Builder> listAssertionsRequest)

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


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

      Parameters:
      listAssertionsRequest - A Consumer that will call methods on ListAssertionsRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listDependencies

      default CompletableFuture<ListDependenciesResponse> listDependencies(ListDependenciesRequest listDependenciesRequest)

      Lists dependencies discovered for services.

      Parameters:
      listDependenciesRequest -
      Returns:
      A Java Future containing the result of the ListDependencies operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listDependencies

      default CompletableFuture<ListDependenciesResponse> listDependencies(Consumer<ListDependenciesRequest.Builder> listDependenciesRequest)

      Lists dependencies discovered for services.


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

      Parameters:
      listDependenciesRequest - A Consumer that will call methods on ListDependenciesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListDependencies operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listDependenciesPaginator

      default ListDependenciesPublisher listDependenciesPaginator(ListDependenciesRequest listDependenciesRequest)

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

      Parameters:
      listDependenciesRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listDependenciesPaginator

      default ListDependenciesPublisher listDependenciesPaginator(Consumer<ListDependenciesRequest.Builder> listDependenciesRequest)

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


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

      Parameters:
      listDependenciesRequest - A Consumer that will call methods on ListDependenciesRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listFailureModeAssessments

      default CompletableFuture<ListFailureModeAssessmentsResponse> listFailureModeAssessments(ListFailureModeAssessmentsRequest listFailureModeAssessmentsRequest)

      Lists failure mode assessments.

      Parameters:
      listFailureModeAssessmentsRequest -
      Returns:
      A Java Future containing the result of the ListFailureModeAssessments operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listFailureModeAssessments

      default CompletableFuture<ListFailureModeAssessmentsResponse> listFailureModeAssessments(Consumer<ListFailureModeAssessmentsRequest.Builder> listFailureModeAssessmentsRequest)

      Lists failure mode assessments.


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

      Parameters:
      listFailureModeAssessmentsRequest - A Consumer that will call methods on ListFailureModeAssessmentsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListFailureModeAssessments operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listFailureModeAssessmentsPaginator

      default ListFailureModeAssessmentsPublisher listFailureModeAssessmentsPaginator(ListFailureModeAssessmentsRequest listFailureModeAssessmentsRequest)

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

      Parameters:
      listFailureModeAssessmentsRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listFailureModeAssessmentsPaginator

      default ListFailureModeAssessmentsPublisher listFailureModeAssessmentsPaginator(Consumer<ListFailureModeAssessmentsRequest.Builder> listFailureModeAssessmentsRequest)

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


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

      Parameters:
      listFailureModeAssessmentsRequest - A Consumer that will call methods on ListFailureModeAssessmentsRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listFailureModeFindings

      default CompletableFuture<ListFailureModeFindingsResponse> listFailureModeFindings(ListFailureModeFindingsRequest listFailureModeFindingsRequest)

      List findings.

      Parameters:
      listFailureModeFindingsRequest -
      Returns:
      A Java Future containing the result of the ListFailureModeFindings operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 Resource not found.
      • InternalServerException Internal service error.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listFailureModeFindings

      default CompletableFuture<ListFailureModeFindingsResponse> listFailureModeFindings(Consumer<ListFailureModeFindingsRequest.Builder> listFailureModeFindingsRequest)

      List findings.


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

      Parameters:
      listFailureModeFindingsRequest - A Consumer that will call methods on ListFailureModeFindingsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListFailureModeFindings operation returned by the service.
      The CompletableFuture returned by this method can be completed 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 Resource not found.
      • InternalServerException Internal service error.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listFailureModeFindingsPaginator

      default ListFailureModeFindingsPublisher listFailureModeFindingsPaginator(ListFailureModeFindingsRequest listFailureModeFindingsRequest)

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

      Parameters:
      listFailureModeFindingsRequest -
      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.
      • ResourceNotFoundException Resource not found.
      • InternalServerException Internal service error.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listFailureModeFindingsPaginator

      default ListFailureModeFindingsPublisher listFailureModeFindingsPaginator(Consumer<ListFailureModeFindingsRequest.Builder> listFailureModeFindingsRequest)

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


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

      Parameters:
      listFailureModeFindingsRequest - A Consumer that will call methods on ListFailureModeFindingsRequest.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.
      • ResourceNotFoundException Resource not found.
      • InternalServerException Internal service error.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listInputSources

      default CompletableFuture<ListInputSourcesResponse> listInputSources(ListInputSourcesRequest listInputSourcesRequest)

      Lists input sources for a service.

      Parameters:
      listInputSourcesRequest -
      Returns:
      A Java Future containing the result of the ListInputSources operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listInputSources

      default CompletableFuture<ListInputSourcesResponse> listInputSources(Consumer<ListInputSourcesRequest.Builder> listInputSourcesRequest)

      Lists input sources for a service.


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

      Parameters:
      listInputSourcesRequest - A Consumer that will call methods on ListInputSourcesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListInputSources operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listInputSourcesPaginator

      default ListInputSourcesPublisher listInputSourcesPaginator(ListInputSourcesRequest listInputSourcesRequest)

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

      Parameters:
      listInputSourcesRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listInputSourcesPaginator

      default ListInputSourcesPublisher listInputSourcesPaginator(Consumer<ListInputSourcesRequest.Builder> listInputSourcesRequest)

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


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

      Parameters:
      listInputSourcesRequest - A Consumer that will call methods on ListInputSourcesRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listPolicies

      default CompletableFuture<ListPoliciesResponse> listPolicies(ListPoliciesRequest listPoliciesRequest)

      Lists resilience policies.

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

    • listPolicies

      default CompletableFuture<ListPoliciesResponse> listPolicies(Consumer<ListPoliciesRequest.Builder> listPoliciesRequest)

      Lists resilience policies.


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

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

    • listPoliciesPaginator

      default ListPoliciesPublisher listPoliciesPaginator(ListPoliciesRequest listPoliciesRequest)

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

      Parameters:
      listPoliciesRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listPoliciesPaginator

      default ListPoliciesPublisher listPoliciesPaginator(Consumer<ListPoliciesRequest.Builder> listPoliciesRequest)

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


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

      Parameters:
      listPoliciesRequest - A Consumer that will call methods on ListPoliciesRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listReports

      default CompletableFuture<ListReportsResponse> listReports(ListReportsRequest listReportsRequest)

      List reports for a service, or all reports owned by the account if serviceArn is not provided.

      Parameters:
      listReportsRequest -
      Returns:
      A Java Future containing the result of the ListReports operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ThrottlingException Too many requests — rate limit exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listReports

      default CompletableFuture<ListReportsResponse> listReports(Consumer<ListReportsRequest.Builder> listReportsRequest)

      List reports for a service, or all reports owned by the account if serviceArn is not provided.


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

      Parameters:
      listReportsRequest - A Consumer that will call methods on ListReportsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListReports operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ThrottlingException Too many requests — rate limit exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listReportsPaginator

      default ListReportsPublisher listReportsPaginator(ListReportsRequest listReportsRequest)

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

      Parameters:
      listReportsRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ThrottlingException Too many requests — rate limit exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listReportsPaginator

      default ListReportsPublisher listReportsPaginator(Consumer<ListReportsRequest.Builder> listReportsRequest)

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


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

      Parameters:
      listReportsRequest - A Consumer that will call methods on ListReportsRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ThrottlingException Too many requests — rate limit exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listResolvedTestRunTargetResources

      default CompletableFuture<ListResolvedTestRunTargetResourcesResponse> listResolvedTestRunTargetResources(ListResolvedTestRunTargetResourcesRequest listResolvedTestRunTargetResourcesRequest)

      Lists the AWS resources that AWS Fault Injection Service (AWS FIS) resolved as targets for a test run.

      Parameters:
      listResolvedTestRunTargetResourcesRequest -
      Returns:
      A Java Future containing the result of the ListResolvedTestRunTargetResources operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listResolvedTestRunTargetResources

      default CompletableFuture<ListResolvedTestRunTargetResourcesResponse> listResolvedTestRunTargetResources(Consumer<ListResolvedTestRunTargetResourcesRequest.Builder> listResolvedTestRunTargetResourcesRequest)

      Lists the AWS resources that AWS Fault Injection Service (AWS FIS) resolved as targets for a test run.


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

      Parameters:
      listResolvedTestRunTargetResourcesRequest - A Consumer that will call methods on ListResolvedTestRunTargetResourcesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListResolvedTestRunTargetResources operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listResolvedTestRunTargetResourcesPaginator

      default ListResolvedTestRunTargetResourcesPublisher listResolvedTestRunTargetResourcesPaginator(ListResolvedTestRunTargetResourcesRequest listResolvedTestRunTargetResourcesRequest)

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

      Parameters:
      listResolvedTestRunTargetResourcesRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listResolvedTestRunTargetResourcesPaginator

      default ListResolvedTestRunTargetResourcesPublisher listResolvedTestRunTargetResourcesPaginator(Consumer<ListResolvedTestRunTargetResourcesRequest.Builder> listResolvedTestRunTargetResourcesRequest)

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


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

      Parameters:
      listResolvedTestRunTargetResourcesRequest - A Consumer that will call methods on ListResolvedTestRunTargetResourcesRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listResources

      default CompletableFuture<ListResourcesResponse> listResources(ListResourcesRequest listResourcesRequest)

      List resources.

      Parameters:
      listResourcesRequest -
      Returns:
      A Java Future containing the result of the ListResources operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listResources

      default CompletableFuture<ListResourcesResponse> listResources(Consumer<ListResourcesRequest.Builder> listResourcesRequest)

      List resources.


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

      Parameters:
      listResourcesRequest - A Consumer that will call methods on ListResourcesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListResources operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listResourcesPaginator

      default ListResourcesPublisher listResourcesPaginator(ListResourcesRequest listResourcesRequest)

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

      Parameters:
      listResourcesRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listResourcesPaginator

      default ListResourcesPublisher listResourcesPaginator(Consumer<ListResourcesRequest.Builder> listResourcesRequest)

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


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

      Parameters:
      listResourcesRequest - A Consumer that will call methods on ListResourcesRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServiceEvents

      default CompletableFuture<ListServiceEventsResponse> listServiceEvents(ListServiceEventsRequest listServiceEventsRequest)

      Lists events for a service.

      Parameters:
      listServiceEventsRequest -
      Returns:
      A Java Future containing the result of the ListServiceEvents operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServiceEvents

      default CompletableFuture<ListServiceEventsResponse> listServiceEvents(Consumer<ListServiceEventsRequest.Builder> listServiceEventsRequest)

      Lists events for a service.


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

      Parameters:
      listServiceEventsRequest - A Consumer that will call methods on ListServiceEventsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListServiceEvents operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServiceEventsPaginator

      default ListServiceEventsPublisher listServiceEventsPaginator(ListServiceEventsRequest listServiceEventsRequest)

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

      Parameters:
      listServiceEventsRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServiceEventsPaginator

      default ListServiceEventsPublisher listServiceEventsPaginator(Consumer<ListServiceEventsRequest.Builder> listServiceEventsRequest)

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


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

      Parameters:
      listServiceEventsRequest - A Consumer that will call methods on ListServiceEventsRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServiceFunctions

      default CompletableFuture<ListServiceFunctionsResponse> listServiceFunctions(ListServiceFunctionsRequest listServiceFunctionsRequest)

      Lists service functions for a service.

      Parameters:
      listServiceFunctionsRequest -
      Returns:
      A Java Future containing the result of the ListServiceFunctions operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServiceFunctions

      default CompletableFuture<ListServiceFunctionsResponse> listServiceFunctions(Consumer<ListServiceFunctionsRequest.Builder> listServiceFunctionsRequest)

      Lists service functions for a service.


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

      Parameters:
      listServiceFunctionsRequest - A Consumer that will call methods on ListServiceFunctionsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListServiceFunctions operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServiceFunctionsPaginator

      default ListServiceFunctionsPublisher listServiceFunctionsPaginator(ListServiceFunctionsRequest listServiceFunctionsRequest)

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

      Parameters:
      listServiceFunctionsRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServiceFunctionsPaginator

      default ListServiceFunctionsPublisher listServiceFunctionsPaginator(Consumer<ListServiceFunctionsRequest.Builder> listServiceFunctionsRequest)

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


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

      Parameters:
      listServiceFunctionsRequest - A Consumer that will call methods on ListServiceFunctionsRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServiceTopologyEdges

      default CompletableFuture<ListServiceTopologyEdgesResponse> listServiceTopologyEdges(ListServiceTopologyEdgesRequest listServiceTopologyEdgesRequest)

      Lists topology edges for a service.

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

    • listServiceTopologyEdges

      default CompletableFuture<ListServiceTopologyEdgesResponse> listServiceTopologyEdges(Consumer<ListServiceTopologyEdgesRequest.Builder> listServiceTopologyEdgesRequest)

      Lists topology edges for a service.


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

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

    • listServiceTopologyEdgesPaginator

      default ListServiceTopologyEdgesPublisher listServiceTopologyEdgesPaginator(ListServiceTopologyEdgesRequest listServiceTopologyEdgesRequest)

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

      Parameters:
      listServiceTopologyEdgesRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServiceTopologyEdgesPaginator

      default ListServiceTopologyEdgesPublisher listServiceTopologyEdgesPaginator(Consumer<ListServiceTopologyEdgesRequest.Builder> listServiceTopologyEdgesRequest)

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


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

      Parameters:
      listServiceTopologyEdgesRequest - A Consumer that will call methods on ListServiceTopologyEdgesRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServices

      default CompletableFuture<ListServicesResponse> listServices(ListServicesRequest listServicesRequest)

      Lists services.

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

    • listServices

      default CompletableFuture<ListServicesResponse> listServices(Consumer<ListServicesRequest.Builder> listServicesRequest)

      Lists services.


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

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

    • listServicesPaginator

      default ListServicesPublisher listServicesPaginator(ListServicesRequest listServicesRequest)

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

      Parameters:
      listServicesRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServicesPaginator

      default ListServicesPublisher listServicesPaginator(Consumer<ListServicesRequest.Builder> listServicesRequest)

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


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

      Parameters:
      listServicesRequest - A Consumer that will call methods on ListServicesRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSystemEvents

      default CompletableFuture<ListSystemEventsResponse> listSystemEvents(ListSystemEventsRequest listSystemEventsRequest)

      Lists events for a system.

      Parameters:
      listSystemEventsRequest -
      Returns:
      A Java Future containing the result of the ListSystemEvents operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSystemEvents

      default CompletableFuture<ListSystemEventsResponse> listSystemEvents(Consumer<ListSystemEventsRequest.Builder> listSystemEventsRequest)

      Lists events for a system.


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

      Parameters:
      listSystemEventsRequest - A Consumer that will call methods on ListSystemEventsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListSystemEvents operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSystemEventsPaginator

      default ListSystemEventsPublisher listSystemEventsPaginator(ListSystemEventsRequest listSystemEventsRequest)

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

      Parameters:
      listSystemEventsRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSystemEventsPaginator

      default ListSystemEventsPublisher listSystemEventsPaginator(Consumer<ListSystemEventsRequest.Builder> listSystemEventsRequest)

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


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

      Parameters:
      listSystemEventsRequest - A Consumer that will call methods on ListSystemEventsRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSystems

      default CompletableFuture<ListSystemsResponse> listSystems(ListSystemsRequest listSystemsRequest)

      Lists systems.

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

    • listSystems

      default CompletableFuture<ListSystemsResponse> listSystems(Consumer<ListSystemsRequest.Builder> listSystemsRequest)

      Lists systems.


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

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

    • listSystemsPaginator

      default ListSystemsPublisher listSystemsPaginator(ListSystemsRequest listSystemsRequest)

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

      Parameters:
      listSystemsRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSystemsPaginator

      default ListSystemsPublisher listSystemsPaginator(Consumer<ListSystemsRequest.Builder> listSystemsRequest)

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


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

      Parameters:
      listSystemsRequest - A Consumer that will call methods on ListSystemsRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTagsForResource

      default CompletableFuture<ListTagsForResourceResponse> listTagsForResource(ListTagsForResourceRequest listTagsForResourceRequest)

      Lists the tags for a resource.

      Parameters:
      listTagsForResourceRequest -
      Returns:
      A Java Future containing the result of the ListTagsForResource operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ThrottlingException Too many requests — rate limit exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTagsForResource

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

      Lists the tags for a resource.


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

      Parameters:
      listTagsForResourceRequest - A Consumer that will call methods on ListTagsForResourceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListTagsForResource operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ThrottlingException Too many requests — rate limit exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTestRunEvents

      default CompletableFuture<ListTestRunEventsResponse> listTestRunEvents(ListTestRunEventsRequest listTestRunEventsRequest)

      Lists the events in a test run's timeline.

      Parameters:
      listTestRunEventsRequest -
      Returns:
      A Java Future containing the result of the ListTestRunEvents operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTestRunEvents

      default CompletableFuture<ListTestRunEventsResponse> listTestRunEvents(Consumer<ListTestRunEventsRequest.Builder> listTestRunEventsRequest)

      Lists the events in a test run's timeline.


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

      Parameters:
      listTestRunEventsRequest - A Consumer that will call methods on ListTestRunEventsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListTestRunEvents operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTestRunEventsPaginator

      default ListTestRunEventsPublisher listTestRunEventsPaginator(ListTestRunEventsRequest listTestRunEventsRequest)

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

      Parameters:
      listTestRunEventsRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTestRunEventsPaginator

      default ListTestRunEventsPublisher listTestRunEventsPaginator(Consumer<ListTestRunEventsRequest.Builder> listTestRunEventsRequest)

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


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

      Parameters:
      listTestRunEventsRequest - A Consumer that will call methods on ListTestRunEventsRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTestRunSources

      default CompletableFuture<ListTestRunSourcesResponse> listTestRunSources(ListTestRunSourcesRequest listTestRunSourcesRequest)

      Lists the monitoring source snapshots captured for a test run, optionally filtered by type.

      Parameters:
      listTestRunSourcesRequest -
      Returns:
      A Java Future containing the result of the ListTestRunSources operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTestRunSources

      default CompletableFuture<ListTestRunSourcesResponse> listTestRunSources(Consumer<ListTestRunSourcesRequest.Builder> listTestRunSourcesRequest)

      Lists the monitoring source snapshots captured for a test run, optionally filtered by type.


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

      Parameters:
      listTestRunSourcesRequest - A Consumer that will call methods on ListTestRunSourcesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListTestRunSources operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTestRunSourcesPaginator

      default ListTestRunSourcesPublisher listTestRunSourcesPaginator(ListTestRunSourcesRequest listTestRunSourcesRequest)

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

      Parameters:
      listTestRunSourcesRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTestRunSourcesPaginator

      default ListTestRunSourcesPublisher listTestRunSourcesPaginator(Consumer<ListTestRunSourcesRequest.Builder> listTestRunSourcesRequest)

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


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

      Parameters:
      listTestRunSourcesRequest - A Consumer that will call methods on ListTestRunSourcesRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTestRuns

      default CompletableFuture<ListTestRunsResponse> listTestRuns(ListTestRunsRequest listTestRunsRequest)

      Lists the runs of a test, or all test runs for a service.

      Parameters:
      listTestRunsRequest -
      Returns:
      A Java Future containing the result of the ListTestRuns operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTestRuns

      default CompletableFuture<ListTestRunsResponse> listTestRuns(Consumer<ListTestRunsRequest.Builder> listTestRunsRequest)

      Lists the runs of a test, or all test runs for a service.


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

      Parameters:
      listTestRunsRequest - A Consumer that will call methods on ListTestRunsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListTestRuns operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTestRunsPaginator

      default ListTestRunsPublisher listTestRunsPaginator(ListTestRunsRequest listTestRunsRequest)

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

      Parameters:
      listTestRunsRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTestRunsPaginator

      default ListTestRunsPublisher listTestRunsPaginator(Consumer<ListTestRunsRequest.Builder> listTestRunsRequest)

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


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

      Parameters:
      listTestRunsRequest - A Consumer that will call methods on ListTestRunsRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTestSources

      default CompletableFuture<ListTestSourcesResponse> listTestSources(ListTestSourcesRequest listTestSourcesRequest)

      Lists the monitoring sources attached to a test, optionally filtered by type.

      Parameters:
      listTestSourcesRequest -
      Returns:
      A Java Future containing the result of the ListTestSources operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTestSources

      default CompletableFuture<ListTestSourcesResponse> listTestSources(Consumer<ListTestSourcesRequest.Builder> listTestSourcesRequest)

      Lists the monitoring sources attached to a test, optionally filtered by type.


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

      Parameters:
      listTestSourcesRequest - A Consumer that will call methods on ListTestSourcesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListTestSources operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTestSourcesPaginator

      default ListTestSourcesPublisher listTestSourcesPaginator(ListTestSourcesRequest listTestSourcesRequest)

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

      Parameters:
      listTestSourcesRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTestSourcesPaginator

      default ListTestSourcesPublisher listTestSourcesPaginator(Consumer<ListTestSourcesRequest.Builder> listTestSourcesRequest)

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


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

      Parameters:
      listTestSourcesRequest - A Consumer that will call methods on ListTestSourcesRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTestTemplates

      default CompletableFuture<ListTestTemplatesResponse> listTestTemplates(ListTestTemplatesRequest listTestTemplatesRequest)

      Lists the available resilience test templates. A test template is a pre-configured, AWS recommended test that defines which resilience capability to validate.

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

    • listTestTemplates

      default CompletableFuture<ListTestTemplatesResponse> listTestTemplates(Consumer<ListTestTemplatesRequest.Builder> listTestTemplatesRequest)

      Lists the available resilience test templates. A test template is a pre-configured, AWS recommended test that defines which resilience capability to validate.


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

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

    • listTests

      default CompletableFuture<ListTestsResponse> listTests(ListTestsRequest listTestsRequest)

      Lists the tests configured for a service.

      Parameters:
      listTestsRequest -
      Returns:
      A Java Future containing the result of the ListTests operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTests

      default CompletableFuture<ListTestsResponse> listTests(Consumer<ListTestsRequest.Builder> listTestsRequest)

      Lists the tests configured for a service.


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

      Parameters:
      listTestsRequest - A Consumer that will call methods on ListTestsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListTests operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTestsPaginator

      default ListTestsPublisher listTestsPaginator(ListTestsRequest listTestsRequest)

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

      Parameters:
      listTestsRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTestsPaginator

      default ListTestsPublisher listTestsPaginator(Consumer<ListTestsRequest.Builder> listTestsRequest)

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


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

      Parameters:
      listTestsRequest - A Consumer that will call methods on ListTestsRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listUserJourneys

      default CompletableFuture<ListUserJourneysResponse> listUserJourneys(ListUserJourneysRequest listUserJourneysRequest)

      Lists user journeys for a system.

      Parameters:
      listUserJourneysRequest -
      Returns:
      A Java Future containing the result of the ListUserJourneys operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listUserJourneys

      default CompletableFuture<ListUserJourneysResponse> listUserJourneys(Consumer<ListUserJourneysRequest.Builder> listUserJourneysRequest)

      Lists user journeys for a system.


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

      Parameters:
      listUserJourneysRequest - A Consumer that will call methods on ListUserJourneysRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListUserJourneys operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listUserJourneysPaginator

      default ListUserJourneysPublisher listUserJourneysPaginator(ListUserJourneysRequest listUserJourneysRequest)

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

      Parameters:
      listUserJourneysRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listUserJourneysPaginator

      default ListUserJourneysPublisher listUserJourneysPaginator(Consumer<ListUserJourneysRequest.Builder> listUserJourneysRequest)

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


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

      Parameters:
      listUserJourneysRequest - A Consumer that will call methods on ListUserJourneysRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • putTestSources

      default CompletableFuture<PutTestSourcesResponse> putTestSources(PutTestSourcesRequest putTestSourcesRequest)

      Adds or updates the monitoring sources on a test. The operation is transactional — either every source is written or the call fails and nothing is written.

      Parameters:
      putTestSourcesRequest -
      Returns:
      A Java Future containing the result of the PutTestSources operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • ServiceQuotaExceededException Service quota exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • putTestSources

      default CompletableFuture<PutTestSourcesResponse> putTestSources(Consumer<PutTestSourcesRequest.Builder> putTestSourcesRequest)

      Adds or updates the monitoring sources on a test. The operation is transactional — either every source is written or the call fails and nothing is written.


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

      Parameters:
      putTestSourcesRequest - A Consumer that will call methods on PutTestSourcesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the PutTestSources operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • ServiceQuotaExceededException Service quota exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • startFailureModeAssessment

      default CompletableFuture<StartFailureModeAssessmentResponse> startFailureModeAssessment(StartFailureModeAssessmentRequest startFailureModeAssessmentRequest)

      Starts a failure mode assessment.

      Parameters:
      startFailureModeAssessmentRequest -
      Returns:
      A Java Future containing the result of the StartFailureModeAssessment operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • ThrottlingException Too many requests — rate limit exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • startFailureModeAssessment

      default CompletableFuture<StartFailureModeAssessmentResponse> startFailureModeAssessment(Consumer<StartFailureModeAssessmentRequest.Builder> startFailureModeAssessmentRequest)

      Starts a failure mode assessment.


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

      Parameters:
      startFailureModeAssessmentRequest - A Consumer that will call methods on StartFailureModeAssessmentRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the StartFailureModeAssessment operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • ThrottlingException Too many requests — rate limit exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • startTestRun

      default CompletableFuture<StartTestRunResponse> startTestRun(StartTestRunRequest startTestRunRequest)

      Starts a run of a test. Each run scopes to the current resources in the service and produces a pass or fail outcome.

      Parameters:
      startTestRunRequest -
      Returns:
      A Java Future containing the result of the StartTestRun operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • startTestRun

      default CompletableFuture<StartTestRunResponse> startTestRun(Consumer<StartTestRunRequest.Builder> startTestRunRequest)

      Starts a run of a test. Each run scopes to the current resources in the service and produces a pass or fail outcome.


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

      Parameters:
      startTestRunRequest - A Consumer that will call methods on StartTestRunRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the StartTestRun operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • stopTestRun

      default CompletableFuture<StopTestRunResponse> stopTestRun(StopTestRunRequest stopTestRunRequest)

      Stops an in-progress test run.

      Parameters:
      stopTestRunRequest -
      Returns:
      A Java Future containing the result of the StopTestRun operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • stopTestRun

      default CompletableFuture<StopTestRunResponse> stopTestRun(Consumer<StopTestRunRequest.Builder> stopTestRunRequest)

      Stops an in-progress test run.


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

      Parameters:
      stopTestRunRequest - A Consumer that will call methods on StopTestRunRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the StopTestRun operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception 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 tags to a resource.

      Parameters:
      tagResourceRequest -
      Returns:
      A Java Future containing the result of the TagResource operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ThrottlingException Too many requests — rate limit exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception 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 tags to a resource.


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

      Parameters:
      tagResourceRequest - A Consumer that will call methods on TagResourceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the TagResource operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ThrottlingException Too many requests — rate limit exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception 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 a resource.

      Parameters:
      untagResourceRequest -
      Returns:
      A Java Future containing the result of the UntagResource operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ThrottlingException Too many requests — rate limit exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception 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 a resource.


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

      Parameters:
      untagResourceRequest - A Consumer that will call methods on UntagResourceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UntagResource operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ThrottlingException Too many requests — rate limit exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateAssertion

      default CompletableFuture<UpdateAssertionResponse> updateAssertion(UpdateAssertionRequest updateAssertionRequest)

      Updates a resilience assertion.

      Parameters:
      updateAssertionRequest -
      Returns:
      A Java Future containing the result of the UpdateAssertion operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateAssertion

      default CompletableFuture<UpdateAssertionResponse> updateAssertion(Consumer<UpdateAssertionRequest.Builder> updateAssertionRequest)

      Updates a resilience assertion.


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

      Parameters:
      updateAssertionRequest - A Consumer that will call methods on UpdateAssertionRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateAssertion operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateDependency

      default CompletableFuture<UpdateDependencyResponse> updateDependency(UpdateDependencyRequest updateDependencyRequest)

      Updates a dependency classification.

      Parameters:
      updateDependencyRequest -
      Returns:
      A Java Future containing the result of the UpdateDependency operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateDependency

      default CompletableFuture<UpdateDependencyResponse> updateDependency(Consumer<UpdateDependencyRequest.Builder> updateDependencyRequest)

      Updates a dependency classification.


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

      Parameters:
      updateDependencyRequest - A Consumer that will call methods on UpdateDependencyRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateDependency operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateFailureModeFinding

      default CompletableFuture<UpdateFailureModeFindingResponse> updateFailureModeFinding(UpdateFailureModeFindingRequest updateFailureModeFindingRequest)

      Updates an existing finding.

      Parameters:
      updateFailureModeFindingRequest -
      Returns:
      A Java Future containing the result of the UpdateFailureModeFinding operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateFailureModeFinding

      default CompletableFuture<UpdateFailureModeFindingResponse> updateFailureModeFinding(Consumer<UpdateFailureModeFindingRequest.Builder> updateFailureModeFindingRequest)

      Updates an existing finding.


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

      Parameters:
      updateFailureModeFindingRequest - A Consumer that will call methods on UpdateFailureModeFindingRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateFailureModeFinding operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updatePolicy

      default CompletableFuture<UpdatePolicyResponse> updatePolicy(UpdatePolicyRequest updatePolicyRequest)

      Updates an existing resilience policy.

      Parameters:
      updatePolicyRequest -
      Returns:
      A Java Future containing the result of the UpdatePolicy operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updatePolicy

      default CompletableFuture<UpdatePolicyResponse> updatePolicy(Consumer<UpdatePolicyRequest.Builder> updatePolicyRequest)

      Updates an existing resilience policy.


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

      Parameters:
      updatePolicyRequest - A Consumer that will call methods on UpdatePolicyRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdatePolicy operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateService

      default CompletableFuture<UpdateServiceResponse> updateService(UpdateServiceRequest updateServiceRequest)

      Updates an existing service.

      Parameters:
      updateServiceRequest -
      Returns:
      A Java Future containing the result of the UpdateService operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • ServiceQuotaExceededException Service quota exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateService

      default CompletableFuture<UpdateServiceResponse> updateService(Consumer<UpdateServiceRequest.Builder> updateServiceRequest)

      Updates an existing service.


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

      Parameters:
      updateServiceRequest - A Consumer that will call methods on UpdateServiceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateService operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • ServiceQuotaExceededException Service quota exceeded.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateServiceFunction

      default CompletableFuture<UpdateServiceFunctionResponse> updateServiceFunction(UpdateServiceFunctionRequest updateServiceFunctionRequest)

      Updates a service function.

      Parameters:
      updateServiceFunctionRequest -
      Returns:
      A Java Future containing the result of the UpdateServiceFunction operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateServiceFunction

      default CompletableFuture<UpdateServiceFunctionResponse> updateServiceFunction(Consumer<UpdateServiceFunctionRequest.Builder> updateServiceFunctionRequest)

      Updates a service function.


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

      Parameters:
      updateServiceFunctionRequest - A Consumer that will call methods on UpdateServiceFunctionRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateServiceFunction operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateSystem

      default CompletableFuture<UpdateSystemResponse> updateSystem(UpdateSystemRequest updateSystemRequest)

      Updates an existing system.

      Parameters:
      updateSystemRequest -
      Returns:
      A Java Future containing the result of the UpdateSystem operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateSystem

      default CompletableFuture<UpdateSystemResponse> updateSystem(Consumer<UpdateSystemRequest.Builder> updateSystemRequest)

      Updates an existing system.


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

      Parameters:
      updateSystemRequest - A Consumer that will call methods on UpdateSystemRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateSystem operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateTest

      default CompletableFuture<UpdateTestResponse> updateTest(UpdateTestRequest updateTestRequest)

      Updates the configuration of an existing test.

      Parameters:
      updateTestRequest -
      Returns:
      A Java Future containing the result of the UpdateTest operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateTest

      default CompletableFuture<UpdateTestResponse> updateTest(Consumer<UpdateTestRequest.Builder> updateTestRequest)

      Updates the configuration of an existing test.


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

      Parameters:
      updateTestRequest - A Consumer that will call methods on UpdateTestRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateTest operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateUserJourney

      default CompletableFuture<UpdateUserJourneyResponse> updateUserJourney(UpdateUserJourneyRequest updateUserJourneyRequest)

      Updates an existing user journey.

      Parameters:
      updateUserJourneyRequest -
      Returns:
      A Java Future containing the result of the UpdateUserJourney operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateUserJourney

      default CompletableFuture<UpdateUserJourneyResponse> updateUserJourney(Consumer<UpdateUserJourneyRequest.Builder> updateUserJourneyRequest)

      Updates an existing user journey.


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

      Parameters:
      updateUserJourneyRequest - A Consumer that will call methods on UpdateUserJourneyRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateUserJourney operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • InternalServerException Internal service error.
      • ResourceNotFoundException Resource not found.
      • ValidationException Validation error — invalid input parameters.
      • ConflictException Conflict — resource already exists.
      • AccessDeniedException Access denied — caller lacks required permissions.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • Resiliencehubv2Exception Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • waiter

      default Resiliencehubv2AsyncWaiter waiter()
      Create an instance of Resiliencehubv2AsyncWaiter using this client.

      Waiters created via this method are managed by the SDK and resources will be released when the service client is closed.

      Returns:
      an instance of Resiliencehubv2AsyncWaiter

    • serviceClientConfiguration

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

    • builder

      static Resiliencehubv2AsyncClientBuilder builder()
      Create a builder that can be used to configure and create a Resiliencehubv2AsyncClient.