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:

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

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

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

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

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

    • startFailureModeAssessment

      default CompletableFuture<StartFailureModeAssessmentResponse> startFailureModeAssessment(StartFailureModeAssessmentRequest startFailureModeAssessmentRequest)

      Start 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)

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

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

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