/*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
/*
* Do not modify this file. This file is generated from the evidently-2021-02-01.normal.json service model.
*/
using System;
using System.Runtime.ExceptionServices;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Net;
using Amazon.CloudWatchEvidently.Model;
using Amazon.CloudWatchEvidently.Model.Internal.MarshallTransformations;
using Amazon.CloudWatchEvidently.Internal;
using Amazon.Runtime;
using Amazon.Runtime.Internal;
using Amazon.Runtime.Internal.Auth;
using Amazon.Runtime.Internal.Transform;
namespace Amazon.CloudWatchEvidently
{
///
/// Implementation for accessing CloudWatchEvidently
///
/// 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.
///
///
public partial class AmazonCloudWatchEvidentlyClient : AmazonServiceClient, IAmazonCloudWatchEvidently
{
private static IServiceMetadata serviceMetadata = new AmazonCloudWatchEvidentlyMetadata();
#region Constructors
///
/// Constructs AmazonCloudWatchEvidentlyClient with the credentials loaded from the application's
/// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance.
///
/// Example App.config with credentials set.
///
/// <?xml version="1.0" encoding="utf-8" ?>
/// <configuration>
/// <appSettings>
/// <add key="AWSProfileName" value="AWS Default"/>
/// </appSettings>
/// </configuration>
///
///
///
public AmazonCloudWatchEvidentlyClient()
: base(FallbackCredentialsFactory.GetCredentials(), new AmazonCloudWatchEvidentlyConfig()) { }
///
/// Constructs AmazonCloudWatchEvidentlyClient with the credentials loaded from the application's
/// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance.
///
/// Example App.config with credentials set.
///
/// <?xml version="1.0" encoding="utf-8" ?>
/// <configuration>
/// <appSettings>
/// <add key="AWSProfileName" value="AWS Default"/>
/// </appSettings>
/// </configuration>
///
///
///
/// The region to connect.
public AmazonCloudWatchEvidentlyClient(RegionEndpoint region)
: base(FallbackCredentialsFactory.GetCredentials(), new AmazonCloudWatchEvidentlyConfig{RegionEndpoint = region}) { }
///
/// Constructs AmazonCloudWatchEvidentlyClient with the credentials loaded from the application's
/// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance.
///
/// Example App.config with credentials set.
///
/// <?xml version="1.0" encoding="utf-8" ?>
/// <configuration>
/// <appSettings>
/// <add key="AWSProfileName" value="AWS Default"/>
/// </appSettings>
/// </configuration>
///
///
///
/// The AmazonCloudWatchEvidentlyClient Configuration Object
public AmazonCloudWatchEvidentlyClient(AmazonCloudWatchEvidentlyConfig config)
: base(FallbackCredentialsFactory.GetCredentials(config), config){}
///
/// Constructs AmazonCloudWatchEvidentlyClient with AWS Credentials
///
/// AWS Credentials
public AmazonCloudWatchEvidentlyClient(AWSCredentials credentials)
: this(credentials, new AmazonCloudWatchEvidentlyConfig())
{
}
///
/// Constructs AmazonCloudWatchEvidentlyClient with AWS Credentials
///
/// AWS Credentials
/// The region to connect.
public AmazonCloudWatchEvidentlyClient(AWSCredentials credentials, RegionEndpoint region)
: this(credentials, new AmazonCloudWatchEvidentlyConfig{RegionEndpoint = region})
{
}
///
/// Constructs AmazonCloudWatchEvidentlyClient with AWS Credentials and an
/// AmazonCloudWatchEvidentlyClient Configuration object.
///
/// AWS Credentials
/// The AmazonCloudWatchEvidentlyClient Configuration Object
public AmazonCloudWatchEvidentlyClient(AWSCredentials credentials, AmazonCloudWatchEvidentlyConfig clientConfig)
: base(credentials, clientConfig)
{
}
///
/// Constructs AmazonCloudWatchEvidentlyClient with AWS Access Key ID and AWS Secret Key
///
/// AWS Access Key ID
/// AWS Secret Access Key
public AmazonCloudWatchEvidentlyClient(string awsAccessKeyId, string awsSecretAccessKey)
: this(awsAccessKeyId, awsSecretAccessKey, new AmazonCloudWatchEvidentlyConfig())
{
}
///
/// Constructs AmazonCloudWatchEvidentlyClient with AWS Access Key ID and AWS Secret Key
///
/// AWS Access Key ID
/// AWS Secret Access Key
/// The region to connect.
public AmazonCloudWatchEvidentlyClient(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region)
: this(awsAccessKeyId, awsSecretAccessKey, new AmazonCloudWatchEvidentlyConfig() {RegionEndpoint=region})
{
}
///
/// Constructs AmazonCloudWatchEvidentlyClient with AWS Access Key ID, AWS Secret Key and an
/// AmazonCloudWatchEvidentlyClient Configuration object.
///
/// AWS Access Key ID
/// AWS Secret Access Key
/// The AmazonCloudWatchEvidentlyClient Configuration Object
public AmazonCloudWatchEvidentlyClient(string awsAccessKeyId, string awsSecretAccessKey, AmazonCloudWatchEvidentlyConfig clientConfig)
: base(awsAccessKeyId, awsSecretAccessKey, clientConfig)
{
}
///
/// Constructs AmazonCloudWatchEvidentlyClient with AWS Access Key ID and AWS Secret Key
///
/// AWS Access Key ID
/// AWS Secret Access Key
/// AWS Session Token
public AmazonCloudWatchEvidentlyClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken)
: this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonCloudWatchEvidentlyConfig())
{
}
///
/// Constructs AmazonCloudWatchEvidentlyClient with AWS Access Key ID and AWS Secret Key
///
/// AWS Access Key ID
/// AWS Secret Access Key
/// AWS Session Token
/// The region to connect.
public AmazonCloudWatchEvidentlyClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region)
: this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonCloudWatchEvidentlyConfig{RegionEndpoint = region})
{
}
///
/// Constructs AmazonCloudWatchEvidentlyClient with AWS Access Key ID, AWS Secret Key and an
/// AmazonCloudWatchEvidentlyClient Configuration object.
///
/// AWS Access Key ID
/// AWS Secret Access Key
/// AWS Session Token
/// The AmazonCloudWatchEvidentlyClient Configuration Object
public AmazonCloudWatchEvidentlyClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonCloudWatchEvidentlyConfig clientConfig)
: base(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, clientConfig)
{
}
#endregion
#if AWS_ASYNC_ENUMERABLES_API
private ICloudWatchEvidentlyPaginatorFactory _paginators;
///
/// Paginators for the service
///
public ICloudWatchEvidentlyPaginatorFactory Paginators
{
get
{
if (this._paginators == null)
{
this._paginators = new CloudWatchEvidentlyPaginatorFactory(this);
}
return this._paginators;
}
}
#endif
#region Overrides
///
/// Creates the signer for the service.
///
protected override AbstractAWSSigner CreateSigner()
{
return new AWS4Signer();
}
///
/// Customizes the runtime pipeline.
///
/// Runtime pipeline for the current client.
protected override void CustomizeRuntimePipeline(RuntimePipeline pipeline)
{
pipeline.RemoveHandler();
pipeline.AddHandlerAfter(new AmazonCloudWatchEvidentlyEndpointResolver());
}
///
/// Capture metadata for the service.
///
protected override IServiceMetadata ServiceMetadata
{
get
{
return serviceMetadata;
}
}
#endregion
#region Dispose
///
/// Disposes the service client.
///
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
}
#endregion
#region BatchEvaluateFeature
internal virtual BatchEvaluateFeatureResponse BatchEvaluateFeature(BatchEvaluateFeatureRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = BatchEvaluateFeatureRequestMarshaller.Instance;
options.ResponseUnmarshaller = BatchEvaluateFeatureResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the BatchEvaluateFeature service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the BatchEvaluateFeature service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// The request references a resource that does not exist.
///
///
/// The request was denied because of request throttling. Retry the request.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for BatchEvaluateFeature Operation
public virtual Task BatchEvaluateFeatureAsync(BatchEvaluateFeatureRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = BatchEvaluateFeatureRequestMarshaller.Instance;
options.ResponseUnmarshaller = BatchEvaluateFeatureResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region CreateExperiment
internal virtual CreateExperimentResponse CreateExperiment(CreateExperimentRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateExperimentRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateExperimentResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
///
/// Container for the necessary parameters to execute the CreateExperiment service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the CreateExperiment service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// A resource was in an inconsistent state during an update or a deletion.
///
///
/// The request references a resource that does not exist.
///
///
/// The request would cause a service quota to be exceeded.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for CreateExperiment Operation
public virtual Task CreateExperimentAsync(CreateExperimentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateExperimentRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateExperimentResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region CreateFeature
internal virtual CreateFeatureResponse CreateFeature(CreateFeatureRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateFeatureRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateFeatureResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
///
/// Container for the necessary parameters to execute the CreateFeature service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the CreateFeature service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// A resource was in an inconsistent state during an update or a deletion.
///
///
/// The request references a resource that does not exist.
///
///
/// The request would cause a service quota to be exceeded.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for CreateFeature Operation
public virtual Task CreateFeatureAsync(CreateFeatureRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateFeatureRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateFeatureResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region CreateLaunch
internal virtual CreateLaunchResponse CreateLaunch(CreateLaunchRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateLaunchRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateLaunchResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
///
/// Container for the necessary parameters to execute the CreateLaunch service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the CreateLaunch service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// A resource was in an inconsistent state during an update or a deletion.
///
///
/// The request references a resource that does not exist.
///
///
/// The request would cause a service quota to be exceeded.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for CreateLaunch Operation
public virtual Task CreateLaunchAsync(CreateLaunchRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateLaunchRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateLaunchResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region CreateProject
internal virtual CreateProjectResponse CreateProject(CreateProjectRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateProjectRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateProjectResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the CreateProject service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the CreateProject service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// A resource was in an inconsistent state during an update or a deletion.
///
///
/// The request would cause a service quota to be exceeded.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for CreateProject Operation
public virtual Task CreateProjectAsync(CreateProjectRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateProjectRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateProjectResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region CreateSegment
internal virtual CreateSegmentResponse CreateSegment(CreateSegmentRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateSegmentRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateSegmentResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the CreateSegment service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the CreateSegment service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// A resource was in an inconsistent state during an update or a deletion.
///
///
/// The request would cause a service quota to be exceeded.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for CreateSegment Operation
public virtual Task CreateSegmentAsync(CreateSegmentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateSegmentRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateSegmentResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DeleteExperiment
internal virtual DeleteExperimentResponse DeleteExperiment(DeleteExperimentRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteExperimentRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteExperimentResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Deletes an Evidently experiment. The feature used for the experiment is not deleted.
///
///
///
/// To stop an experiment without deleting it, use StopExperiment.
///
///
///
/// Container for the necessary parameters to execute the DeleteExperiment service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DeleteExperiment service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// A resource was in an inconsistent state during an update or a deletion.
///
///
/// Unexpected error while processing the request. Retry the request.
///
///
/// The request references a resource that does not exist.
///
///
/// The service was unavailable. Retry the request.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for DeleteExperiment Operation
public virtual Task DeleteExperimentAsync(DeleteExperimentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteExperimentRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteExperimentResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DeleteFeature
internal virtual DeleteFeatureResponse DeleteFeature(DeleteFeatureRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteFeatureRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteFeatureResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Deletes an Evidently feature.
///
/// Container for the necessary parameters to execute the DeleteFeature service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DeleteFeature service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// A resource was in an inconsistent state during an update or a deletion.
///
///
/// The request references a resource that does not exist.
///
///
/// The request was denied because of request throttling. Retry the request.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for DeleteFeature Operation
public virtual Task DeleteFeatureAsync(DeleteFeatureRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteFeatureRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteFeatureResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DeleteLaunch
internal virtual DeleteLaunchResponse DeleteLaunch(DeleteLaunchRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteLaunchRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteLaunchResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Deletes an Evidently launch. The feature used for the launch is not deleted.
///
///
///
/// To stop a launch without deleting it, use StopLaunch.
///
///
///
/// Container for the necessary parameters to execute the DeleteLaunch service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DeleteLaunch service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// A resource was in an inconsistent state during an update or a deletion.
///
///
/// The request references a resource that does not exist.
///
///
/// The request was denied because of request throttling. Retry the request.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for DeleteLaunch Operation
public virtual Task DeleteLaunchAsync(DeleteLaunchRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteLaunchRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteLaunchResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DeleteProject
internal virtual DeleteProjectResponse DeleteProject(DeleteProjectRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteProjectRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteProjectResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
/// Container for the necessary parameters to execute the DeleteProject service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DeleteProject service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// A resource was in an inconsistent state during an update or a deletion.
///
///
/// The request references a resource that does not exist.
///
///
/// The request was denied because of request throttling. Retry the request.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for DeleteProject Operation
public virtual Task DeleteProjectAsync(DeleteProjectRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteProjectRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteProjectResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DeleteSegment
internal virtual DeleteSegmentResponse DeleteSegment(DeleteSegmentRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteSegmentRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteSegmentResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
/// Container for the necessary parameters to execute the DeleteSegment service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DeleteSegment service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// A resource was in an inconsistent state during an update or a deletion.
///
///
/// The request references a resource that does not exist.
///
///
/// The request was denied because of request throttling. Retry the request.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for DeleteSegment Operation
public virtual Task DeleteSegmentAsync(DeleteSegmentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteSegmentRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteSegmentResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region EvaluateFeature
internal virtual EvaluateFeatureResponse EvaluateFeature(EvaluateFeatureRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = EvaluateFeatureRequestMarshaller.Instance;
options.ResponseUnmarshaller = EvaluateFeatureResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the EvaluateFeature service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the EvaluateFeature service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// The request references a resource that does not exist.
///
///
/// The request was denied because of request throttling. Retry the request.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for EvaluateFeature Operation
public virtual Task EvaluateFeatureAsync(EvaluateFeatureRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = EvaluateFeatureRequestMarshaller.Instance;
options.ResponseUnmarshaller = EvaluateFeatureResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetExperiment
internal virtual GetExperimentResponse GetExperiment(GetExperimentRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetExperimentRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetExperimentResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Returns the details about one experiment. You must already know the experiment name.
/// To retrieve a list of experiments in your account, use ListExperiments.
///
/// Container for the necessary parameters to execute the GetExperiment service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetExperiment service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// The request references a resource that does not exist.
///
///
/// The request was denied because of request throttling. Retry the request.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for GetExperiment Operation
public virtual Task GetExperimentAsync(GetExperimentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetExperimentRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetExperimentResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetExperimentResults
internal virtual GetExperimentResultsResponse GetExperimentResults(GetExperimentResultsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetExperimentResultsRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetExperimentResultsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the GetExperimentResults service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetExperimentResults service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// A resource was in an inconsistent state during an update or a deletion.
///
///
/// The request references a resource that does not exist.
///
///
/// The request was denied because of request throttling. Retry the request.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for GetExperimentResults Operation
public virtual Task GetExperimentResultsAsync(GetExperimentResultsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetExperimentResultsRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetExperimentResultsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetFeature
internal virtual GetFeatureResponse GetFeature(GetFeatureRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetFeatureRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetFeatureResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Returns the details about one feature. You must already know the feature name. To
/// retrieve a list of features in your account, use ListFeatures.
///
/// Container for the necessary parameters to execute the GetFeature service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetFeature service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// The request references a resource that does not exist.
///
///
/// The request was denied because of request throttling. Retry the request.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for GetFeature Operation
public virtual Task GetFeatureAsync(GetFeatureRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetFeatureRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetFeatureResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetLaunch
internal virtual GetLaunchResponse GetLaunch(GetLaunchRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetLaunchRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetLaunchResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Returns the details about one launch. You must already know the launch name. To retrieve
/// a list of launches in your account, use ListLaunches.
///
/// Container for the necessary parameters to execute the GetLaunch service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetLaunch service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// The request references a resource that does not exist.
///
///
/// The request was denied because of request throttling. Retry the request.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for GetLaunch Operation
public virtual Task GetLaunchAsync(GetLaunchRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetLaunchRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetLaunchResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetProject
internal virtual GetProjectResponse GetProject(GetProjectRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetProjectRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetProjectResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Returns the details about one launch. You must already know the project name. To retrieve
/// a list of projects in your account, use ListProjects.
///
/// Container for the necessary parameters to execute the GetProject service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetProject service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// The request references a resource that does not exist.
///
///
/// The request was denied because of request throttling. Retry the request.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for GetProject Operation
public virtual Task GetProjectAsync(GetProjectRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetProjectRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetProjectResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region GetSegment
internal virtual GetSegmentResponse GetSegment(GetSegmentRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetSegmentRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetSegmentResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Returns information about the specified segment. Specify the segment you want to view
/// by specifying its ARN.
///
/// Container for the necessary parameters to execute the GetSegment service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the GetSegment service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// The request references a resource that does not exist.
///
///
/// The request was denied because of request throttling. Retry the request.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for GetSegment Operation
public virtual Task GetSegmentAsync(GetSegmentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetSegmentRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetSegmentResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region ListExperiments
internal virtual ListExperimentsResponse ListExperiments(ListExperimentsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListExperimentsRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListExperimentsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Returns configuration details about all the experiments in the specified project.
///
/// Container for the necessary parameters to execute the ListExperiments service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the ListExperiments service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// The request references a resource that does not exist.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for ListExperiments Operation
public virtual Task ListExperimentsAsync(ListExperimentsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = ListExperimentsRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListExperimentsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region ListFeatures
internal virtual ListFeaturesResponse ListFeatures(ListFeaturesRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListFeaturesRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListFeaturesResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Returns configuration details about all the features in the specified project.
///
/// Container for the necessary parameters to execute the ListFeatures service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the ListFeatures service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// The request references a resource that does not exist.
///
///
/// The request was denied because of request throttling. Retry the request.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for ListFeatures Operation
public virtual Task ListFeaturesAsync(ListFeaturesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = ListFeaturesRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListFeaturesResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region ListLaunches
internal virtual ListLaunchesResponse ListLaunches(ListLaunchesRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListLaunchesRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListLaunchesResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Returns configuration details about all the launches in the specified project.
///
/// Container for the necessary parameters to execute the ListLaunches service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the ListLaunches service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// The request was denied because of request throttling. Retry the request.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for ListLaunches Operation
public virtual Task ListLaunchesAsync(ListLaunchesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = ListLaunchesRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListLaunchesResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region ListProjects
internal virtual ListProjectsResponse ListProjects(ListProjectsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListProjectsRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListProjectsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Returns configuration details about all the projects in the current Region in your
/// account.
///
/// Container for the necessary parameters to execute the ListProjects service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the ListProjects service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// The request was denied because of request throttling. Retry the request.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for ListProjects Operation
public virtual Task ListProjectsAsync(ListProjectsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = ListProjectsRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListProjectsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region ListSegmentReferences
internal virtual ListSegmentReferencesResponse ListSegmentReferences(ListSegmentReferencesRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListSegmentReferencesRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListSegmentReferencesResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Use this operation to find which experiments or launches are using a specified segment.
///
/// Container for the necessary parameters to execute the ListSegmentReferences service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the ListSegmentReferences service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// The request references a resource that does not exist.
///
///
/// The request was denied because of request throttling. Retry the request.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for ListSegmentReferences Operation
public virtual Task ListSegmentReferencesAsync(ListSegmentReferencesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = ListSegmentReferencesRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListSegmentReferencesResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region ListSegments
internal virtual ListSegmentsResponse ListSegments(ListSegmentsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListSegmentsRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListSegmentsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Returns a list of audience segments that you have created in your account in this
/// Region.
///
/// Container for the necessary parameters to execute the ListSegments service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the ListSegments service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// The request was denied because of request throttling. Retry the request.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for ListSegments Operation
public virtual Task ListSegmentsAsync(ListSegmentsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = ListSegmentsRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListSegmentsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region ListTagsForResource
internal virtual ListTagsForResourceResponse ListTagsForResource(ListTagsForResourceRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Displays the tags associated with an Evidently resource.
///
/// Container for the necessary parameters to execute the ListTagsForResource service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the ListTagsForResource service method, as returned by CloudWatchEvidently.
///
/// A resource was in an inconsistent state during an update or a deletion.
///
///
/// The request references a resource that does not exist.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for ListTagsForResource Operation
public virtual Task ListTagsForResourceAsync(ListTagsForResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region PutProjectEvents
internal virtual PutProjectEventsResponse PutProjectEvents(PutProjectEventsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = PutProjectEventsRequestMarshaller.Instance;
options.ResponseUnmarshaller = PutProjectEventsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Sends performance events to Evidently. These events can be used to evaluate a launch
/// or an experiment.
///
/// Container for the necessary parameters to execute the PutProjectEvents service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the PutProjectEvents service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// The request references a resource that does not exist.
///
///
/// The request was denied because of request throttling. Retry the request.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for PutProjectEvents Operation
public virtual Task PutProjectEventsAsync(PutProjectEventsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = PutProjectEventsRequestMarshaller.Instance;
options.ResponseUnmarshaller = PutProjectEventsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region StartExperiment
internal virtual StartExperimentResponse StartExperiment(StartExperimentRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = StartExperimentRequestMarshaller.Instance;
options.ResponseUnmarshaller = StartExperimentResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Starts an existing experiment. To create an experiment, use CreateExperiment.
///
/// Container for the necessary parameters to execute the StartExperiment service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the StartExperiment service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// A resource was in an inconsistent state during an update or a deletion.
///
///
/// The request references a resource that does not exist.
///
///
/// The request would cause a service quota to be exceeded.
///
///
/// The request was denied because of request throttling. Retry the request.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for StartExperiment Operation
public virtual Task StartExperimentAsync(StartExperimentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = StartExperimentRequestMarshaller.Instance;
options.ResponseUnmarshaller = StartExperimentResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region StartLaunch
internal virtual StartLaunchResponse StartLaunch(StartLaunchRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = StartLaunchRequestMarshaller.Instance;
options.ResponseUnmarshaller = StartLaunchResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Starts an existing launch. To create a launch, use CreateLaunch.
///
/// Container for the necessary parameters to execute the StartLaunch service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the StartLaunch service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// A resource was in an inconsistent state during an update or a deletion.
///
///
/// The request references a resource that does not exist.
///
///
/// The request would cause a service quota to be exceeded.
///
///
/// The request was denied because of request throttling. Retry the request.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for StartLaunch Operation
public virtual Task StartLaunchAsync(StartLaunchRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = StartLaunchRequestMarshaller.Instance;
options.ResponseUnmarshaller = StartLaunchResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region StopExperiment
internal virtual StopExperimentResponse StopExperiment(StopExperimentRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = StopExperimentRequestMarshaller.Instance;
options.ResponseUnmarshaller = StopExperimentResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Stops an experiment that is currently running. If you stop an experiment, you can't
/// resume it or restart it.
///
/// Container for the necessary parameters to execute the StopExperiment service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the StopExperiment service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// A resource was in an inconsistent state during an update or a deletion.
///
///
/// The request references a resource that does not exist.
///
///
/// The request would cause a service quota to be exceeded.
///
///
/// The request was denied because of request throttling. Retry the request.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for StopExperiment Operation
public virtual Task StopExperimentAsync(StopExperimentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = StopExperimentRequestMarshaller.Instance;
options.ResponseUnmarshaller = StopExperimentResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region StopLaunch
internal virtual StopLaunchResponse StopLaunch(StopLaunchRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = StopLaunchRequestMarshaller.Instance;
options.ResponseUnmarshaller = StopLaunchResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
/// Container for the necessary parameters to execute the StopLaunch service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the StopLaunch service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// The request references a resource that does not exist.
///
///
/// The request was denied because of request throttling. Retry the request.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for StopLaunch Operation
public virtual Task StopLaunchAsync(StopLaunchRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = StopLaunchRequestMarshaller.Instance;
options.ResponseUnmarshaller = StopLaunchResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region TagResource
internal virtual TagResourceResponse TagResource(TagResourceRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = TagResourceRequestMarshaller.Instance;
options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the TagResource service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the TagResource service method, as returned by CloudWatchEvidently.
///
/// A resource was in an inconsistent state during an update or a deletion.
///
///
/// The request references a resource that does not exist.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for TagResource Operation
public virtual Task TagResourceAsync(TagResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = TagResourceRequestMarshaller.Instance;
options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region TestSegmentPattern
internal virtual TestSegmentPatternResponse TestSegmentPattern(TestSegmentPatternRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = TestSegmentPatternRequestMarshaller.Instance;
options.ResponseUnmarshaller = TestSegmentPatternResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
/// Container for the necessary parameters to execute the TestSegmentPattern service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the TestSegmentPattern service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// The request was denied because of request throttling. Retry the request.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for TestSegmentPattern Operation
public virtual Task TestSegmentPatternAsync(TestSegmentPatternRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = TestSegmentPatternRequestMarshaller.Instance;
options.ResponseUnmarshaller = TestSegmentPatternResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region UntagResource
internal virtual UntagResourceResponse UntagResource(UntagResourceRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UntagResourceRequestMarshaller.Instance;
options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Removes one or more tags from the specified resource.
///
/// Container for the necessary parameters to execute the UntagResource service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the UntagResource service method, as returned by CloudWatchEvidently.
///
/// A resource was in an inconsistent state during an update or a deletion.
///
///
/// The request references a resource that does not exist.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for UntagResource Operation
public virtual Task UntagResourceAsync(UntagResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = UntagResourceRequestMarshaller.Instance;
options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region UpdateExperiment
internal virtual UpdateExperimentResponse UpdateExperiment(UpdateExperimentRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateExperimentRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateExperimentResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Updates an Evidently experiment.
///
///
///
/// Don't use this operation to update an experiment's tag. Instead, use TagResource.
///
///
///
/// Container for the necessary parameters to execute the UpdateExperiment service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the UpdateExperiment service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// A resource was in an inconsistent state during an update or a deletion.
///
///
/// The request references a resource that does not exist.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for UpdateExperiment Operation
public virtual Task UpdateExperimentAsync(UpdateExperimentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateExperimentRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateExperimentResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region UpdateFeature
internal virtual UpdateFeatureResponse UpdateFeature(UpdateFeatureRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateFeatureRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateFeatureResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Updates an existing feature.
///
///
///
/// You can't use this operation to update the tags of an existing feature. Instead, use
/// TagResource.
///
///
///
/// Container for the necessary parameters to execute the UpdateFeature service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the UpdateFeature service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// A resource was in an inconsistent state during an update or a deletion.
///
///
/// The request references a resource that does not exist.
///
///
/// The request would cause a service quota to be exceeded.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for UpdateFeature Operation
public virtual Task UpdateFeatureAsync(UpdateFeatureRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateFeatureRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateFeatureResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region UpdateLaunch
internal virtual UpdateLaunchResponse UpdateLaunch(UpdateLaunchRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateLaunchRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateLaunchResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Updates a launch of a given feature.
///
///
///
/// Don't use this operation to update the tags of an existing launch. Instead, use TagResource.
///
///
///
/// Container for the necessary parameters to execute the UpdateLaunch service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the UpdateLaunch service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// A resource was in an inconsistent state during an update or a deletion.
///
///
/// The request references a resource that does not exist.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for UpdateLaunch Operation
public virtual Task UpdateLaunchAsync(UpdateLaunchRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateLaunchRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateLaunchResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region UpdateProject
internal virtual UpdateProjectResponse UpdateProject(UpdateProjectRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateProjectRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateProjectResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
///
/// Container for the necessary parameters to execute the UpdateProject service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the UpdateProject service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// A resource was in an inconsistent state during an update or a deletion.
///
///
/// The request references a resource that does not exist.
///
///
/// The request would cause a service quota to be exceeded.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for UpdateProject Operation
public virtual Task UpdateProjectAsync(UpdateProjectRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateProjectRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateProjectResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region UpdateProjectDataDelivery
internal virtual UpdateProjectDataDeliveryResponse UpdateProjectDataDelivery(UpdateProjectDataDeliveryRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateProjectDataDeliveryRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateProjectDataDeliveryResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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.
///
///
/// Container for the necessary parameters to execute the UpdateProjectDataDelivery service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the UpdateProjectDataDelivery service method, as returned by CloudWatchEvidently.
///
/// You do not have sufficient permissions to perform this action.
///
///
/// A resource was in an inconsistent state during an update or a deletion.
///
///
/// The request references a resource that does not exist.
///
///
/// The request would cause a service quota to be exceeded.
///
///
/// The value of a parameter in the request caused an error.
///
/// REST API Reference for UpdateProjectDataDelivery Operation
public virtual Task UpdateProjectDataDeliveryAsync(UpdateProjectDataDeliveryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateProjectDataDeliveryRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateProjectDataDeliveryResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
}
}