Interface EvidentlyAsyncClient

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

You can use Amazon CloudWatch Evidently to safely validate new features by serving them to a specified percentage of your users while you roll out the feature. You can monitor the performance of the new feature to help you decide when to ramp up traffic to your users. This helps you reduce risk and identify unintended consequences before you fully launch the feature.

You can also conduct A/B experiments to make feature design decisions based on evidence and data. An experiment can test as many as five variations at once. Evidently collects experiment data and analyzes it using statistical methods. It also provides clear recommendations about which variations perform better. You can test both user-facing features and backend features.

  • Field Details

  • Method Details

    • batchEvaluateFeature

      default CompletableFuture<BatchEvaluateFeatureResponse> batchEvaluateFeature(BatchEvaluateFeatureRequest batchEvaluateFeatureRequest)

      This operation assigns feature variation to user sessions. For each user session, you pass in an entityID that represents the user. Evidently then checks the evaluation rules and assigns the variation.

      The first rules that are evaluated are the override rules. If the user's entityID matches an override rule, the user is served the variation specified by that rule.

      Next, if there is a launch of the feature, the user might be assigned to a variation in the launch. The chance of this depends on the percentage of users that are allocated to that launch. If the user is enrolled in the launch, the variation they are served depends on the allocation of the various feature variations used for the launch.

      If the user is not assigned to a launch, and there is an ongoing experiment for this feature, the user might be assigned to a variation in the experiment. The chance of this depends on the percentage of users that are allocated to that experiment. If the user is enrolled in the experiment, the variation they are served depends on the allocation of the various feature variations used for the experiment.

      If the user is not assigned to a launch or experiment, they are served the default variation.

      Parameters:
      batchEvaluateFeatureRequest -
      Returns:
      A Java Future containing the result of the BatchEvaluateFeature operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • batchEvaluateFeature

      default CompletableFuture<BatchEvaluateFeatureResponse> batchEvaluateFeature(Consumer<BatchEvaluateFeatureRequest.Builder> batchEvaluateFeatureRequest)

      This operation assigns feature variation to user sessions. For each user session, you pass in an entityID that represents the user. Evidently then checks the evaluation rules and assigns the variation.

      The first rules that are evaluated are the override rules. If the user's entityID matches an override rule, the user is served the variation specified by that rule.

      Next, if there is a launch of the feature, the user might be assigned to a variation in the launch. The chance of this depends on the percentage of users that are allocated to that launch. If the user is enrolled in the launch, the variation they are served depends on the allocation of the various feature variations used for the launch.

      If the user is not assigned to a launch, and there is an ongoing experiment for this feature, the user might be assigned to a variation in the experiment. The chance of this depends on the percentage of users that are allocated to that experiment. If the user is enrolled in the experiment, the variation they are served depends on the allocation of the various feature variations used for the experiment.

      If the user is not assigned to a launch or experiment, they are served the default variation.


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

      Parameters:
      batchEvaluateFeatureRequest - A Consumer that will call methods on BatchEvaluateFeatureRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the BatchEvaluateFeature operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createExperiment

      default CompletableFuture<CreateExperimentResponse> createExperiment(CreateExperimentRequest createExperimentRequest)

      Creates an Evidently experiment. Before you create an experiment, you must create the feature to use for the experiment.

      An experiment helps you make feature design decisions based on evidence and data. An experiment can test as many as five variations at once. Evidently collects experiment data and analyzes it by statistical methods, and provides clear recommendations about which variations perform better.

      You can optionally specify a segment to have the experiment consider only certain audience types in the experiment, such as using only user sessions from a certain location or who use a certain internet browser.

      Don't use this operation to update an existing experiment. Instead, use UpdateExperiment.

      Parameters:
      createExperimentRequest -
      Returns:
      A Java Future containing the result of the CreateExperiment operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createExperiment

      default CompletableFuture<CreateExperimentResponse> createExperiment(Consumer<CreateExperimentRequest.Builder> createExperimentRequest)

      Creates an Evidently experiment. Before you create an experiment, you must create the feature to use for the experiment.

      An experiment helps you make feature design decisions based on evidence and data. An experiment can test as many as five variations at once. Evidently collects experiment data and analyzes it by statistical methods, and provides clear recommendations about which variations perform better.

      You can optionally specify a segment to have the experiment consider only certain audience types in the experiment, such as using only user sessions from a certain location or who use a certain internet browser.

      Don't use this operation to update an existing experiment. Instead, use UpdateExperiment.


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

      Parameters:
      createExperimentRequest - A Consumer that will call methods on CreateExperimentRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateExperiment operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createFeature

      default CompletableFuture<CreateFeatureResponse> createFeature(CreateFeatureRequest createFeatureRequest)

      Creates an Evidently feature that you want to launch or test. You can define up to five variations of a feature, and use these variations in your launches and experiments. A feature must be created in a project. For information about creating a project, see CreateProject.

      Don't use this operation to update an existing feature. Instead, use UpdateFeature.

      Parameters:
      createFeatureRequest -
      Returns:
      A Java Future containing the result of the CreateFeature operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createFeature

      default CompletableFuture<CreateFeatureResponse> createFeature(Consumer<CreateFeatureRequest.Builder> createFeatureRequest)

      Creates an Evidently feature that you want to launch or test. You can define up to five variations of a feature, and use these variations in your launches and experiments. A feature must be created in a project. For information about creating a project, see CreateProject.

      Don't use this operation to update an existing feature. Instead, use UpdateFeature.


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

      Parameters:
      createFeatureRequest - A Consumer that will call methods on CreateFeatureRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateFeature operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createLaunch

      default CompletableFuture<CreateLaunchResponse> createLaunch(CreateLaunchRequest createLaunchRequest)

      Creates a launch of a given feature. Before you create a launch, you must create the feature to use for the launch.

      You can use a launch to safely validate new features by serving them to a specified percentage of your users while you roll out the feature. You can monitor the performance of the new feature to help you decide when to ramp up traffic to more users. This helps you reduce risk and identify unintended consequences before you fully launch the feature.

      Don't use this operation to update an existing launch. Instead, use UpdateLaunch.

      Parameters:
      createLaunchRequest -
      Returns:
      A Java Future containing the result of the CreateLaunch operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createLaunch

      default CompletableFuture<CreateLaunchResponse> createLaunch(Consumer<CreateLaunchRequest.Builder> createLaunchRequest)

      Creates a launch of a given feature. Before you create a launch, you must create the feature to use for the launch.

      You can use a launch to safely validate new features by serving them to a specified percentage of your users while you roll out the feature. You can monitor the performance of the new feature to help you decide when to ramp up traffic to more users. This helps you reduce risk and identify unintended consequences before you fully launch the feature.

      Don't use this operation to update an existing launch. Instead, use UpdateLaunch.


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

      Parameters:
      createLaunchRequest - A Consumer that will call methods on CreateLaunchRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateLaunch operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createProject

      default CompletableFuture<CreateProjectResponse> createProject(CreateProjectRequest createProjectRequest)

      Creates a project, which is the logical object in Evidently that can contain features, launches, and experiments. Use projects to group similar features together.

      To update an existing project, use UpdateProject.

      Parameters:
      createProjectRequest -
      Returns:
      A Java Future containing the result of the CreateProject operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createProject

      default CompletableFuture<CreateProjectResponse> createProject(Consumer<CreateProjectRequest.Builder> createProjectRequest)

      Creates a project, which is the logical object in Evidently that can contain features, launches, and experiments. Use projects to group similar features together.

      To update an existing project, use UpdateProject.


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

      Parameters:
      createProjectRequest - A Consumer that will call methods on CreateProjectRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateProject operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createSegment

      default CompletableFuture<CreateSegmentResponse> createSegment(CreateSegmentRequest createSegmentRequest)

      Use this operation to define a segment of your audience. A segment is a portion of your audience that share one or more characteristics. Examples could be Chrome browser users, users in Europe, or Firefox browser users in Europe who also fit other criteria that your application collects, such as age.

      Using a segment in an experiment limits that experiment to evaluate only the users who match the segment criteria. Using one or more segments in a launch allows you to define different traffic splits for the different audience segments.

      For more information about segment pattern syntax, see Segment rule pattern syntax.

      The pattern that you define for a segment is matched against the value of evaluationContext, which is passed into Evidently in the EvaluateFeature operation, when Evidently assigns a feature variation to a user.

      Parameters:
      createSegmentRequest -
      Returns:
      A Java Future containing the result of the CreateSegment operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createSegment

      default CompletableFuture<CreateSegmentResponse> createSegment(Consumer<CreateSegmentRequest.Builder> createSegmentRequest)

      Use this operation to define a segment of your audience. A segment is a portion of your audience that share one or more characteristics. Examples could be Chrome browser users, users in Europe, or Firefox browser users in Europe who also fit other criteria that your application collects, such as age.

      Using a segment in an experiment limits that experiment to evaluate only the users who match the segment criteria. Using one or more segments in a launch allows you to define different traffic splits for the different audience segments.

      For more information about segment pattern syntax, see Segment rule pattern syntax.

      The pattern that you define for a segment is matched against the value of evaluationContext, which is passed into Evidently in the EvaluateFeature operation, when Evidently assigns a feature variation to a user.


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

      Parameters:
      createSegmentRequest - A Consumer that will call methods on CreateSegmentRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateSegment operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteExperiment

      default CompletableFuture<DeleteExperimentResponse> deleteExperiment(DeleteExperimentRequest deleteExperimentRequest)

      Deletes an Evidently experiment. The feature used for the experiment is not deleted.

      To stop an experiment without deleting it, use StopExperiment.

      Parameters:
      deleteExperimentRequest -
      Returns:
      A Java Future containing the result of the DeleteExperiment operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The value of a parameter in the request caused an error.
      • InternalServerException Unexpected error while processing the request. Retry the request.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ServiceUnavailableException The service was unavailable. Retry the request.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteExperiment

      default CompletableFuture<DeleteExperimentResponse> deleteExperiment(Consumer<DeleteExperimentRequest.Builder> deleteExperimentRequest)

      Deletes an Evidently experiment. The feature used for the experiment is not deleted.

      To stop an experiment without deleting it, use StopExperiment.


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

      Parameters:
      deleteExperimentRequest - A Consumer that will call methods on DeleteExperimentRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteExperiment operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The value of a parameter in the request caused an error.
      • InternalServerException Unexpected error while processing the request. Retry the request.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ServiceUnavailableException The service was unavailable. Retry the request.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteFeature

      default CompletableFuture<DeleteFeatureResponse> deleteFeature(DeleteFeatureRequest deleteFeatureRequest)

      Deletes an Evidently feature.

      Parameters:
      deleteFeatureRequest -
      Returns:
      A Java Future containing the result of the DeleteFeature operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteFeature

      default CompletableFuture<DeleteFeatureResponse> deleteFeature(Consumer<DeleteFeatureRequest.Builder> deleteFeatureRequest)

      Deletes an Evidently feature.


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

      Parameters:
      deleteFeatureRequest - A Consumer that will call methods on DeleteFeatureRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteFeature operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteLaunch

      default CompletableFuture<DeleteLaunchResponse> deleteLaunch(DeleteLaunchRequest deleteLaunchRequest)

      Deletes an Evidently launch. The feature used for the launch is not deleted.

      To stop a launch without deleting it, use StopLaunch.

      Parameters:
      deleteLaunchRequest -
      Returns:
      A Java Future containing the result of the DeleteLaunch operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteLaunch

      default CompletableFuture<DeleteLaunchResponse> deleteLaunch(Consumer<DeleteLaunchRequest.Builder> deleteLaunchRequest)

      Deletes an Evidently launch. The feature used for the launch is not deleted.

      To stop a launch without deleting it, use StopLaunch.


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

      Parameters:
      deleteLaunchRequest - A Consumer that will call methods on DeleteLaunchRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteLaunch operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteProject

      default CompletableFuture<DeleteProjectResponse> deleteProject(DeleteProjectRequest deleteProjectRequest)

      Deletes an Evidently project. Before you can delete a project, you must delete all the features that the project contains. To delete a feature, use DeleteFeature.

      Parameters:
      deleteProjectRequest -
      Returns:
      A Java Future containing the result of the DeleteProject operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteProject

      default CompletableFuture<DeleteProjectResponse> deleteProject(Consumer<DeleteProjectRequest.Builder> deleteProjectRequest)

      Deletes an Evidently project. Before you can delete a project, you must delete all the features that the project contains. To delete a feature, use DeleteFeature.


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

      Parameters:
      deleteProjectRequest - A Consumer that will call methods on DeleteProjectRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteProject operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteSegment

      default CompletableFuture<DeleteSegmentResponse> deleteSegment(DeleteSegmentRequest deleteSegmentRequest)

      Deletes a segment. You can't delete a segment that is being used in a launch or experiment, even if that launch or experiment is not currently running.

      Parameters:
      deleteSegmentRequest -
      Returns:
      A Java Future containing the result of the DeleteSegment operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteSegment

      default CompletableFuture<DeleteSegmentResponse> deleteSegment(Consumer<DeleteSegmentRequest.Builder> deleteSegmentRequest)

      Deletes a segment. You can't delete a segment that is being used in a launch or experiment, even if that launch or experiment is not currently running.


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

      Parameters:
      deleteSegmentRequest - A Consumer that will call methods on DeleteSegmentRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteSegment operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • evaluateFeature

      default CompletableFuture<EvaluateFeatureResponse> evaluateFeature(EvaluateFeatureRequest evaluateFeatureRequest)

      This operation assigns a feature variation to one given user session. You pass in an entityID that represents the user. Evidently then checks the evaluation rules and assigns the variation.

      The first rules that are evaluated are the override rules. If the user's entityID matches an override rule, the user is served the variation specified by that rule.

      If there is a current launch with this feature that uses segment overrides, and if the user session's evaluationContext matches a segment rule defined in a segment override, the configuration in the segment overrides is used. For more information about segments, see CreateSegment and Use segments to focus your audience.

      If there is a launch with no segment overrides, the user might be assigned to a variation in the launch. The chance of this depends on the percentage of users that are allocated to that launch. If the user is enrolled in the launch, the variation they are served depends on the allocation of the various feature variations used for the launch.

      If the user is not assigned to a launch, and there is an ongoing experiment for this feature, the user might be assigned to a variation in the experiment. The chance of this depends on the percentage of users that are allocated to that experiment.

      If the experiment uses a segment, then only user sessions with evaluationContext values that match the segment rule are used in the experiment.

      If the user is enrolled in the experiment, the variation they are served depends on the allocation of the various feature variations used for the experiment.

      If the user is not assigned to a launch or experiment, they are served the default variation.

      Parameters:
      evaluateFeatureRequest -
      Returns:
      A Java Future containing the result of the EvaluateFeature operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • evaluateFeature

      default CompletableFuture<EvaluateFeatureResponse> evaluateFeature(Consumer<EvaluateFeatureRequest.Builder> evaluateFeatureRequest)

      This operation assigns a feature variation to one given user session. You pass in an entityID that represents the user. Evidently then checks the evaluation rules and assigns the variation.

      The first rules that are evaluated are the override rules. If the user's entityID matches an override rule, the user is served the variation specified by that rule.

      If there is a current launch with this feature that uses segment overrides, and if the user session's evaluationContext matches a segment rule defined in a segment override, the configuration in the segment overrides is used. For more information about segments, see CreateSegment and Use segments to focus your audience.

      If there is a launch with no segment overrides, the user might be assigned to a variation in the launch. The chance of this depends on the percentage of users that are allocated to that launch. If the user is enrolled in the launch, the variation they are served depends on the allocation of the various feature variations used for the launch.

      If the user is not assigned to a launch, and there is an ongoing experiment for this feature, the user might be assigned to a variation in the experiment. The chance of this depends on the percentage of users that are allocated to that experiment.

      If the experiment uses a segment, then only user sessions with evaluationContext values that match the segment rule are used in the experiment.

      If the user is enrolled in the experiment, the variation they are served depends on the allocation of the various feature variations used for the experiment.

      If the user is not assigned to a launch or experiment, they are served the default variation.


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

      Parameters:
      evaluateFeatureRequest - A Consumer that will call methods on EvaluateFeatureRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the EvaluateFeature operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getExperiment

      default CompletableFuture<GetExperimentResponse> getExperiment(GetExperimentRequest getExperimentRequest)

      Returns the details about one experiment. You must already know the experiment name. To retrieve a list of experiments in your account, use ListExperiments.

      Parameters:
      getExperimentRequest -
      Returns:
      A Java Future containing the result of the GetExperiment operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getExperiment

      default CompletableFuture<GetExperimentResponse> getExperiment(Consumer<GetExperimentRequest.Builder> getExperimentRequest)

      Returns the details about one experiment. You must already know the experiment name. To retrieve a list of experiments in your account, use ListExperiments.


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

      Parameters:
      getExperimentRequest - A Consumer that will call methods on GetExperimentRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetExperiment operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getExperimentResults

      default CompletableFuture<GetExperimentResultsResponse> getExperimentResults(GetExperimentResultsRequest getExperimentResultsRequest)

      Retrieves the results of a running or completed experiment. No results are available until there have been 100 events for each variation and at least 10 minutes have passed since the start of the experiment. To increase the statistical power, Evidently performs an additional offline p-value analysis at the end of the experiment. Offline p-value analysis can detect statistical significance in some cases where the anytime p-values used during the experiment do not find statistical significance.

      Experiment results are available up to 63 days after the start of the experiment. They are not available after that because of CloudWatch data retention policies.

      Parameters:
      getExperimentResultsRequest -
      Returns:
      A Java Future containing the result of the GetExperimentResults operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getExperimentResults

      default CompletableFuture<GetExperimentResultsResponse> getExperimentResults(Consumer<GetExperimentResultsRequest.Builder> getExperimentResultsRequest)

      Retrieves the results of a running or completed experiment. No results are available until there have been 100 events for each variation and at least 10 minutes have passed since the start of the experiment. To increase the statistical power, Evidently performs an additional offline p-value analysis at the end of the experiment. Offline p-value analysis can detect statistical significance in some cases where the anytime p-values used during the experiment do not find statistical significance.

      Experiment results are available up to 63 days after the start of the experiment. They are not available after that because of CloudWatch data retention policies.


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

      Parameters:
      getExperimentResultsRequest - A Consumer that will call methods on GetExperimentResultsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetExperimentResults operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getFeature

      default CompletableFuture<GetFeatureResponse> getFeature(GetFeatureRequest getFeatureRequest)

      Returns the details about one feature. You must already know the feature name. To retrieve a list of features in your account, use ListFeatures.

      Parameters:
      getFeatureRequest -
      Returns:
      A Java Future containing the result of the GetFeature operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getFeature

      default CompletableFuture<GetFeatureResponse> getFeature(Consumer<GetFeatureRequest.Builder> getFeatureRequest)

      Returns the details about one feature. You must already know the feature name. To retrieve a list of features in your account, use ListFeatures.


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

      Parameters:
      getFeatureRequest - A Consumer that will call methods on GetFeatureRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetFeature operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getLaunch

      default CompletableFuture<GetLaunchResponse> getLaunch(GetLaunchRequest getLaunchRequest)

      Returns the details about one launch. You must already know the launch name. To retrieve a list of launches in your account, use ListLaunches.

      Parameters:
      getLaunchRequest -
      Returns:
      A Java Future containing the result of the GetLaunch operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getLaunch

      default CompletableFuture<GetLaunchResponse> getLaunch(Consumer<GetLaunchRequest.Builder> getLaunchRequest)

      Returns the details about one launch. You must already know the launch name. To retrieve a list of launches in your account, use ListLaunches.


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

      Parameters:
      getLaunchRequest - A Consumer that will call methods on GetLaunchRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetLaunch operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getProject

      default CompletableFuture<GetProjectResponse> getProject(GetProjectRequest getProjectRequest)

      Returns the details about one launch. You must already know the project name. To retrieve a list of projects in your account, use ListProjects.

      Parameters:
      getProjectRequest -
      Returns:
      A Java Future containing the result of the GetProject operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getProject

      default CompletableFuture<GetProjectResponse> getProject(Consumer<GetProjectRequest.Builder> getProjectRequest)

      Returns the details about one launch. You must already know the project name. To retrieve a list of projects in your account, use ListProjects.


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

      Parameters:
      getProjectRequest - A Consumer that will call methods on GetProjectRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetProject operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getSegment

      default CompletableFuture<GetSegmentResponse> getSegment(GetSegmentRequest getSegmentRequest)

      Returns information about the specified segment. Specify the segment you want to view by specifying its ARN.

      Parameters:
      getSegmentRequest -
      Returns:
      A Java Future containing the result of the GetSegment operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getSegment

      default CompletableFuture<GetSegmentResponse> getSegment(Consumer<GetSegmentRequest.Builder> getSegmentRequest)

      Returns information about the specified segment. Specify the segment you want to view by specifying its ARN.


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

      Parameters:
      getSegmentRequest - A Consumer that will call methods on GetSegmentRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetSegment operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listExperiments

      default CompletableFuture<ListExperimentsResponse> listExperiments(ListExperimentsRequest listExperimentsRequest)

      Returns configuration details about all the experiments in the specified project.

      Parameters:
      listExperimentsRequest -
      Returns:
      A Java Future containing the result of the ListExperiments operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listExperiments

      default CompletableFuture<ListExperimentsResponse> listExperiments(Consumer<ListExperimentsRequest.Builder> listExperimentsRequest)

      Returns configuration details about all the experiments in the specified project.


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

      Parameters:
      listExperimentsRequest - A Consumer that will call methods on ListExperimentsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListExperiments operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listExperimentsPaginator

      default ListExperimentsPublisher listExperimentsPaginator(ListExperimentsRequest listExperimentsRequest)

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

      Parameters:
      listExperimentsRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listExperimentsPaginator

      default ListExperimentsPublisher listExperimentsPaginator(Consumer<ListExperimentsRequest.Builder> listExperimentsRequest)

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


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

      Parameters:
      listExperimentsRequest - A Consumer that will call methods on ListExperimentsRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listFeatures

      default CompletableFuture<ListFeaturesResponse> listFeatures(ListFeaturesRequest listFeaturesRequest)

      Returns configuration details about all the features in the specified project.

      Parameters:
      listFeaturesRequest -
      Returns:
      A Java Future containing the result of the ListFeatures operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listFeatures

      default CompletableFuture<ListFeaturesResponse> listFeatures(Consumer<ListFeaturesRequest.Builder> listFeaturesRequest)

      Returns configuration details about all the features in the specified project.


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

      Parameters:
      listFeaturesRequest - A Consumer that will call methods on ListFeaturesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListFeatures operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listFeaturesPaginator

      default ListFeaturesPublisher listFeaturesPaginator(ListFeaturesRequest listFeaturesRequest)

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

      Parameters:
      listFeaturesRequest -
      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.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listFeaturesPaginator

      default ListFeaturesPublisher listFeaturesPaginator(Consumer<ListFeaturesRequest.Builder> listFeaturesRequest)

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


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

      Parameters:
      listFeaturesRequest - A Consumer that will call methods on ListFeaturesRequest.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.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listLaunches

      default CompletableFuture<ListLaunchesResponse> listLaunches(ListLaunchesRequest listLaunchesRequest)

      Returns configuration details about all the launches in the specified project.

      Parameters:
      listLaunchesRequest -
      Returns:
      A Java Future containing the result of the ListLaunches operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listLaunches

      default CompletableFuture<ListLaunchesResponse> listLaunches(Consumer<ListLaunchesRequest.Builder> listLaunchesRequest)

      Returns configuration details about all the launches in the specified project.


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

      Parameters:
      listLaunchesRequest - A Consumer that will call methods on ListLaunchesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListLaunches operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listLaunchesPaginator

      default ListLaunchesPublisher listLaunchesPaginator(ListLaunchesRequest listLaunchesRequest)

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

      Parameters:
      listLaunchesRequest -
      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.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listLaunchesPaginator

      default ListLaunchesPublisher listLaunchesPaginator(Consumer<ListLaunchesRequest.Builder> listLaunchesRequest)

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


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

      Parameters:
      listLaunchesRequest - A Consumer that will call methods on ListLaunchesRequest.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.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listProjects

      default CompletableFuture<ListProjectsResponse> listProjects(ListProjectsRequest listProjectsRequest)

      Returns configuration details about all the projects in the current Region in your account.

      Parameters:
      listProjectsRequest -
      Returns:
      A Java Future containing the result of the ListProjects operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listProjects

      default CompletableFuture<ListProjectsResponse> listProjects(Consumer<ListProjectsRequest.Builder> listProjectsRequest)

      Returns configuration details about all the projects in the current Region in your account.


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

      Parameters:
      listProjectsRequest - A Consumer that will call methods on ListProjectsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListProjects operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listProjectsPaginator

      default ListProjectsPublisher listProjectsPaginator(ListProjectsRequest listProjectsRequest)

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

      Parameters:
      listProjectsRequest -
      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.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listProjectsPaginator

      default ListProjectsPublisher listProjectsPaginator(Consumer<ListProjectsRequest.Builder> listProjectsRequest)

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


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

      Parameters:
      listProjectsRequest - A Consumer that will call methods on ListProjectsRequest.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.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSegmentReferences

      default CompletableFuture<ListSegmentReferencesResponse> listSegmentReferences(ListSegmentReferencesRequest listSegmentReferencesRequest)

      Use this operation to find which experiments or launches are using a specified segment.

      Parameters:
      listSegmentReferencesRequest -
      Returns:
      A Java Future containing the result of the ListSegmentReferences operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSegmentReferences

      default CompletableFuture<ListSegmentReferencesResponse> listSegmentReferences(Consumer<ListSegmentReferencesRequest.Builder> listSegmentReferencesRequest)

      Use this operation to find which experiments or launches are using a specified segment.


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

      Parameters:
      listSegmentReferencesRequest - A Consumer that will call methods on ListSegmentReferencesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListSegmentReferences operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSegmentReferencesPaginator

      default ListSegmentReferencesPublisher listSegmentReferencesPaginator(ListSegmentReferencesRequest listSegmentReferencesRequest)

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

      Parameters:
      listSegmentReferencesRequest -
      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.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSegmentReferencesPaginator

      default ListSegmentReferencesPublisher listSegmentReferencesPaginator(Consumer<ListSegmentReferencesRequest.Builder> listSegmentReferencesRequest)

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


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

      Parameters:
      listSegmentReferencesRequest - A Consumer that will call methods on ListSegmentReferencesRequest.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.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSegments

      default CompletableFuture<ListSegmentsResponse> listSegments(ListSegmentsRequest listSegmentsRequest)

      Returns a list of audience segments that you have created in your account in this Region.

      Parameters:
      listSegmentsRequest -
      Returns:
      A Java Future containing the result of the ListSegments operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSegments

      default CompletableFuture<ListSegmentsResponse> listSegments(Consumer<ListSegmentsRequest.Builder> listSegmentsRequest)

      Returns a list of audience segments that you have created in your account in this Region.


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

      Parameters:
      listSegmentsRequest - A Consumer that will call methods on ListSegmentsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListSegments operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSegmentsPaginator

      default ListSegmentsPublisher listSegmentsPaginator(ListSegmentsRequest listSegmentsRequest)

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

      Parameters:
      listSegmentsRequest -
      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.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listSegmentsPaginator

      default ListSegmentsPublisher listSegmentsPaginator(Consumer<ListSegmentsRequest.Builder> listSegmentsRequest)

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


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

      Parameters:
      listSegmentsRequest - A Consumer that will call methods on ListSegmentsRequest.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.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException 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)

      Displays the tags associated with an Evidently 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.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ResourceNotFoundException The request references a resource that does not exist.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException 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)

      Displays the tags associated with an Evidently 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.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ResourceNotFoundException The request references a resource that does not exist.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • putProjectEvents

      default CompletableFuture<PutProjectEventsResponse> putProjectEvents(PutProjectEventsRequest putProjectEventsRequest)

      Sends performance events to Evidently. These events can be used to evaluate a launch or an experiment.

      Parameters:
      putProjectEventsRequest -
      Returns:
      A Java Future containing the result of the PutProjectEvents operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • putProjectEvents

      default CompletableFuture<PutProjectEventsResponse> putProjectEvents(Consumer<PutProjectEventsRequest.Builder> putProjectEventsRequest)

      Sends performance events to Evidently. These events can be used to evaluate a launch or an experiment.


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

      Parameters:
      putProjectEventsRequest - A Consumer that will call methods on PutProjectEventsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the PutProjectEvents operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • startExperiment

      default CompletableFuture<StartExperimentResponse> startExperiment(StartExperimentRequest startExperimentRequest)

      Starts an existing experiment. To create an experiment, use CreateExperiment.

      Parameters:
      startExperimentRequest -
      Returns:
      A Java Future containing the result of the StartExperiment operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • startExperiment

      default CompletableFuture<StartExperimentResponse> startExperiment(Consumer<StartExperimentRequest.Builder> startExperimentRequest)

      Starts an existing experiment. To create an experiment, use CreateExperiment.


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

      Parameters:
      startExperimentRequest - A Consumer that will call methods on StartExperimentRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the StartExperiment operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • startLaunch

      default CompletableFuture<StartLaunchResponse> startLaunch(StartLaunchRequest startLaunchRequest)

      Starts an existing launch. To create a launch, use CreateLaunch.

      Parameters:
      startLaunchRequest -
      Returns:
      A Java Future containing the result of the StartLaunch operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • startLaunch

      default CompletableFuture<StartLaunchResponse> startLaunch(Consumer<StartLaunchRequest.Builder> startLaunchRequest)

      Starts an existing launch. To create a launch, use CreateLaunch.


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

      Parameters:
      startLaunchRequest - A Consumer that will call methods on StartLaunchRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the StartLaunch operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • stopExperiment

      default CompletableFuture<StopExperimentResponse> stopExperiment(StopExperimentRequest stopExperimentRequest)

      Stops an experiment that is currently running. If you stop an experiment, you can't resume it or restart it.

      Parameters:
      stopExperimentRequest -
      Returns:
      A Java Future containing the result of the StopExperiment operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • stopExperiment

      default CompletableFuture<StopExperimentResponse> stopExperiment(Consumer<StopExperimentRequest.Builder> stopExperimentRequest)

      Stops an experiment that is currently running. If you stop an experiment, you can't resume it or restart it.


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

      Parameters:
      stopExperimentRequest - A Consumer that will call methods on StopExperimentRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the StopExperiment operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • stopLaunch

      default CompletableFuture<StopLaunchResponse> stopLaunch(StopLaunchRequest stopLaunchRequest)

      Stops a launch that is currently running. After you stop a launch, you will not be able to resume it or restart it. Also, it will not be evaluated as a rule for traffic allocation, and the traffic that was allocated to the launch will instead be available to the feature's experiment, if there is one. Otherwise, all traffic will be served the default variation after the launch is stopped.

      Parameters:
      stopLaunchRequest -
      Returns:
      A Java Future containing the result of the StopLaunch operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • stopLaunch

      default CompletableFuture<StopLaunchResponse> stopLaunch(Consumer<StopLaunchRequest.Builder> stopLaunchRequest)

      Stops a launch that is currently running. After you stop a launch, you will not be able to resume it or restart it. Also, it will not be evaluated as a rule for traffic allocation, and the traffic that was allocated to the launch will instead be available to the feature's experiment, if there is one. Otherwise, all traffic will be served the default variation after the launch is stopped.


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

      Parameters:
      stopLaunchRequest - A Consumer that will call methods on StopLaunchRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the StopLaunch operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • tagResource

      default CompletableFuture<TagResourceResponse> tagResource(TagResourceRequest tagResourceRequest)

      Assigns one or more tags (key-value pairs) to the specified CloudWatch Evidently resource. Projects, features, launches, and experiments can be tagged.

      Tags can help you organize and categorize your resources. You can also use them to scope user permissions by granting a user permission to access or change only resources with certain tag values.

      Tags don't have any semantic meaning to Amazon Web Services and are interpreted strictly as strings of characters.

      You can use the TagResource action with a resource that already has tags. If you specify a new tag key for the resource, this tag is appended to the list of tags associated with the alarm. If you specify a tag key that is already associated with the resource, the new tag value that you specify replaces the previous value for that tag.

      You can associate as many as 50 tags with a resource.

      For more information, see Tagging Amazon Web Services resources.

      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.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ResourceNotFoundException The request references a resource that does not exist.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • tagResource

      default CompletableFuture<TagResourceResponse> tagResource(Consumer<TagResourceRequest.Builder> tagResourceRequest)

      Assigns one or more tags (key-value pairs) to the specified CloudWatch Evidently resource. Projects, features, launches, and experiments can be tagged.

      Tags can help you organize and categorize your resources. You can also use them to scope user permissions by granting a user permission to access or change only resources with certain tag values.

      Tags don't have any semantic meaning to Amazon Web Services and are interpreted strictly as strings of characters.

      You can use the TagResource action with a resource that already has tags. If you specify a new tag key for the resource, this tag is appended to the list of tags associated with the alarm. If you specify a tag key that is already associated with the resource, the new tag value that you specify replaces the previous value for that tag.

      You can associate as many as 50 tags with a resource.

      For more information, see Tagging Amazon Web Services resources.


      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.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ResourceNotFoundException The request references a resource that does not exist.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • testSegmentPattern

      default CompletableFuture<TestSegmentPatternResponse> testSegmentPattern(TestSegmentPatternRequest testSegmentPatternRequest)

      Use this operation to test a rules pattern that you plan to use to create an audience segment. For more information about segments, see CreateSegment.

      Parameters:
      testSegmentPatternRequest -
      Returns:
      A Java Future containing the result of the TestSegmentPattern operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • testSegmentPattern

      default CompletableFuture<TestSegmentPatternResponse> testSegmentPattern(Consumer<TestSegmentPatternRequest.Builder> testSegmentPatternRequest)

      Use this operation to test a rules pattern that you plan to use to create an audience segment. For more information about segments, see CreateSegment.


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

      Parameters:
      testSegmentPatternRequest - A Consumer that will call methods on TestSegmentPatternRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the TestSegmentPattern operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ThrottlingException The request was denied because of request throttling. Retry the request.
      • ValidationException The value of a parameter in the request caused an error.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException 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 one or more tags from the specified 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.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ResourceNotFoundException The request references a resource that does not exist.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException 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 one or more tags from the specified 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.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ResourceNotFoundException The request references a resource that does not exist.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateExperiment

      default CompletableFuture<UpdateExperimentResponse> updateExperiment(UpdateExperimentRequest updateExperimentRequest)

      Updates an Evidently experiment.

      Don't use this operation to update an experiment's tag. Instead, use TagResource.

      Parameters:
      updateExperimentRequest -
      Returns:
      A Java Future containing the result of the UpdateExperiment operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateExperiment

      default CompletableFuture<UpdateExperimentResponse> updateExperiment(Consumer<UpdateExperimentRequest.Builder> updateExperimentRequest)

      Updates an Evidently experiment.

      Don't use this operation to update an experiment's tag. Instead, use TagResource.


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

      Parameters:
      updateExperimentRequest - A Consumer that will call methods on UpdateExperimentRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateExperiment operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateFeature

      default CompletableFuture<UpdateFeatureResponse> updateFeature(UpdateFeatureRequest updateFeatureRequest)

      Updates an existing feature.

      You can't use this operation to update the tags of an existing feature. Instead, use TagResource.

      Parameters:
      updateFeatureRequest -
      Returns:
      A Java Future containing the result of the UpdateFeature operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateFeature

      default CompletableFuture<UpdateFeatureResponse> updateFeature(Consumer<UpdateFeatureRequest.Builder> updateFeatureRequest)

      Updates an existing feature.

      You can't use this operation to update the tags of an existing feature. Instead, use TagResource.


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

      Parameters:
      updateFeatureRequest - A Consumer that will call methods on UpdateFeatureRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateFeature operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateLaunch

      default CompletableFuture<UpdateLaunchResponse> updateLaunch(UpdateLaunchRequest updateLaunchRequest)

      Updates a launch of a given feature.

      Don't use this operation to update the tags of an existing launch. Instead, use TagResource.

      Parameters:
      updateLaunchRequest -
      Returns:
      A Java Future containing the result of the UpdateLaunch operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateLaunch

      default CompletableFuture<UpdateLaunchResponse> updateLaunch(Consumer<UpdateLaunchRequest.Builder> updateLaunchRequest)

      Updates a launch of a given feature.

      Don't use this operation to update the tags of an existing launch. Instead, use TagResource.


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

      Parameters:
      updateLaunchRequest - A Consumer that will call methods on UpdateLaunchRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateLaunch operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateProject

      default CompletableFuture<UpdateProjectResponse> updateProject(UpdateProjectRequest updateProjectRequest)

      Updates the description of an existing project.

      To create a new project, use CreateProject.

      Don't use this operation to update the data storage options of a project. Instead, use UpdateProjectDataDelivery.

      Don't use this operation to update the tags of a project. Instead, use TagResource.

      Parameters:
      updateProjectRequest -
      Returns:
      A Java Future containing the result of the UpdateProject operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateProject

      default CompletableFuture<UpdateProjectResponse> updateProject(Consumer<UpdateProjectRequest.Builder> updateProjectRequest)

      Updates the description of an existing project.

      To create a new project, use CreateProject.

      Don't use this operation to update the data storage options of a project. Instead, use UpdateProjectDataDelivery.

      Don't use this operation to update the tags of a project. Instead, use TagResource.


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

      Parameters:
      updateProjectRequest - A Consumer that will call methods on UpdateProjectRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateProject operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateProjectDataDelivery

      default CompletableFuture<UpdateProjectDataDeliveryResponse> updateProjectDataDelivery(UpdateProjectDataDeliveryRequest updateProjectDataDeliveryRequest)

      Updates the data storage options for this project. If you store evaluation events, you an keep them and analyze them on your own. If you choose not to store evaluation events, Evidently deletes them after using them to produce metrics and other experiment results that you can view.

      You can't specify both cloudWatchLogs and s3Destination in the same operation.

      Parameters:
      updateProjectDataDeliveryRequest -
      Returns:
      A Java Future containing the result of the UpdateProjectDataDelivery operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateProjectDataDelivery

      default CompletableFuture<UpdateProjectDataDeliveryResponse> updateProjectDataDelivery(Consumer<UpdateProjectDataDeliveryRequest.Builder> updateProjectDataDeliveryRequest)

      Updates the data storage options for this project. If you store evaluation events, you an keep them and analyze them on your own. If you choose not to store evaluation events, Evidently deletes them after using them to produce metrics and other experiment results that you can view.

      You can't specify both cloudWatchLogs and s3Destination in the same operation.


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

      Parameters:
      updateProjectDataDeliveryRequest - A Consumer that will call methods on UpdateProjectDataDeliveryRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateProjectDataDelivery operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The value of a parameter in the request caused an error.
      • ConflictException A resource was in an inconsistent state during an update or a deletion.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • AccessDeniedException You do not have sufficient permissions to perform this action.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • EvidentlyException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • serviceClientConfiguration

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

    • builder

      static EvidentlyAsyncClientBuilder builder()
      Create a builder that can be used to configure and create a EvidentlyAsyncClient.