/* * 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.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(); #if BCL45 || 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 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()) { } ///


        /// <?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}) { } ///


        /// <?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 #region Overrides ///

/// Creates the signer for the service. ///

protected override AbstractAWSSigner CreateSigner() { return new AWS4Signer(); } ///

/// Customize the pipeline ///

/// 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 ///

/// 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. /// /// 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 BatchEvaluateFeatureResponse BatchEvaluateFeature(BatchEvaluateFeatureRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = BatchEvaluateFeatureRequestMarshaller.Instance; options.ResponseUnmarshaller = BatchEvaluateFeatureResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the BatchEvaluateFeature operation. ///

/// /// Container for the necessary parameters to execute the BatchEvaluateFeature operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndBatchEvaluateFeature /// operation. /// REST API Reference for BatchEvaluateFeature Operation public virtual IAsyncResult BeginBatchEvaluateFeature(BatchEvaluateFeatureRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = BatchEvaluateFeatureRequestMarshaller.Instance; options.ResponseUnmarshaller = BatchEvaluateFeatureResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the BatchEvaluateFeature operation. ///

/// /// The IAsyncResult returned by the call to BeginBatchEvaluateFeature. /// /// Returns a BatchEvaluateFeatureResult from CloudWatchEvidently. /// REST API Reference for BatchEvaluateFeature Operation public virtual BatchEvaluateFeatureResponse EndBatchEvaluateFeature(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateExperiment ///

/// 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. /// /// 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 CreateExperimentResponse CreateExperiment(CreateExperimentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateExperimentRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateExperimentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateExperiment operation. ///

/// /// Container for the necessary parameters to execute the CreateExperiment operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateExperiment /// operation. /// REST API Reference for CreateExperiment Operation public virtual IAsyncResult BeginCreateExperiment(CreateExperimentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateExperimentRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateExperimentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateExperiment operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateExperiment. /// /// Returns a CreateExperimentResult from CloudWatchEvidently. /// REST API Reference for CreateExperiment Operation public virtual CreateExperimentResponse EndCreateExperiment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateFeature ///

/// 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. /// /// 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 CreateFeatureResponse CreateFeature(CreateFeatureRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateFeatureRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateFeatureResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateFeature operation. ///

/// /// Container for the necessary parameters to execute the CreateFeature operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateFeature /// operation. /// REST API Reference for CreateFeature Operation public virtual IAsyncResult BeginCreateFeature(CreateFeatureRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateFeatureRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateFeatureResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateFeature operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateFeature. /// /// Returns a CreateFeatureResult from CloudWatchEvidently. /// REST API Reference for CreateFeature Operation public virtual CreateFeatureResponse EndCreateFeature(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateLaunch ///

/// 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. /// /// 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 CreateLaunchResponse CreateLaunch(CreateLaunchRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLaunchRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLaunchResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateLaunch operation. ///

/// /// Container for the necessary parameters to execute the CreateLaunch operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateLaunch /// operation. /// REST API Reference for CreateLaunch Operation public virtual IAsyncResult BeginCreateLaunch(CreateLaunchRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLaunchRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLaunchResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateLaunch operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateLaunch. /// /// Returns a CreateLaunchResult from CloudWatchEvidently. /// REST API Reference for CreateLaunch Operation public virtual CreateLaunchResponse EndCreateLaunch(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateProject ///

/// 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. /// /// 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 CreateProjectResponse CreateProject(CreateProjectRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateProjectRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateProjectResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateProject operation. ///

/// /// Container for the necessary parameters to execute the CreateProject operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateProject /// operation. /// REST API Reference for CreateProject Operation public virtual IAsyncResult BeginCreateProject(CreateProjectRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateProjectRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateProjectResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateProject operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateProject. /// /// Returns a CreateProjectResult from CloudWatchEvidently. /// REST API Reference for CreateProject Operation public virtual CreateProjectResponse EndCreateProject(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateSegment ///

/// 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. /// /// 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 CreateSegmentResponse CreateSegment(CreateSegmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSegmentRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSegmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateSegment operation. ///

/// /// Container for the necessary parameters to execute the CreateSegment operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateSegment /// operation. /// REST API Reference for CreateSegment Operation public virtual IAsyncResult BeginCreateSegment(CreateSegmentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSegmentRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSegmentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateSegment operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateSegment. /// /// Returns a CreateSegmentResult from CloudWatchEvidently. /// REST API Reference for CreateSegment Operation public virtual CreateSegmentResponse EndCreateSegment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteExperiment ///

/// 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. /// /// 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 DeleteExperimentResponse DeleteExperiment(DeleteExperimentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteExperimentRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteExperimentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteExperiment operation. ///

/// /// Container for the necessary parameters to execute the DeleteExperiment operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteExperiment /// operation. /// REST API Reference for DeleteExperiment Operation public virtual IAsyncResult BeginDeleteExperiment(DeleteExperimentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteExperimentRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteExperimentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteExperiment operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteExperiment. /// /// Returns a DeleteExperimentResult from CloudWatchEvidently. /// REST API Reference for DeleteExperiment Operation public virtual DeleteExperimentResponse EndDeleteExperiment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteFeature ///

/// Deletes an Evidently feature. ///

/// Container for the necessary parameters to execute the DeleteFeature service method. /// /// 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 DeleteFeatureResponse DeleteFeature(DeleteFeatureRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteFeatureRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteFeatureResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteFeature operation. ///

/// /// Container for the necessary parameters to execute the DeleteFeature operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteFeature /// operation. /// REST API Reference for DeleteFeature Operation public virtual IAsyncResult BeginDeleteFeature(DeleteFeatureRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteFeatureRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteFeatureResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteFeature operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteFeature. /// /// Returns a DeleteFeatureResult from CloudWatchEvidently. /// REST API Reference for DeleteFeature Operation public virtual DeleteFeatureResponse EndDeleteFeature(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteLaunch ///

/// 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. /// /// 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 DeleteLaunchResponse DeleteLaunch(DeleteLaunchRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteLaunchRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteLaunchResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteLaunch operation. ///

/// /// Container for the necessary parameters to execute the DeleteLaunch operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteLaunch /// operation. /// REST API Reference for DeleteLaunch Operation public virtual IAsyncResult BeginDeleteLaunch(DeleteLaunchRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteLaunchRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteLaunchResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteLaunch operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteLaunch. /// /// Returns a DeleteLaunchResult from CloudWatchEvidently. /// REST API Reference for DeleteLaunch Operation public virtual DeleteLaunchResponse EndDeleteLaunch(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteProject ///

/// 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. /// /// 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 DeleteProjectResponse DeleteProject(DeleteProjectRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteProjectRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteProjectResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteProject operation. ///

/// /// Container for the necessary parameters to execute the DeleteProject operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteProject /// operation. /// REST API Reference for DeleteProject Operation public virtual IAsyncResult BeginDeleteProject(DeleteProjectRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteProjectRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteProjectResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteProject operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteProject. /// /// Returns a DeleteProjectResult from CloudWatchEvidently. /// REST API Reference for DeleteProject Operation public virtual DeleteProjectResponse EndDeleteProject(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteSegment ///

/// 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. /// /// 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 DeleteSegmentResponse DeleteSegment(DeleteSegmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSegmentRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSegmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteSegment operation. ///

/// /// Container for the necessary parameters to execute the DeleteSegment operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteSegment /// operation. /// REST API Reference for DeleteSegment Operation public virtual IAsyncResult BeginDeleteSegment(DeleteSegmentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSegmentRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSegmentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteSegment operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteSegment. /// /// Returns a DeleteSegmentResult from CloudWatchEvidently. /// REST API Reference for DeleteSegment Operation public virtual DeleteSegmentResponse EndDeleteSegment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region EvaluateFeature ///

/// 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. /// /// 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 EvaluateFeatureResponse EvaluateFeature(EvaluateFeatureRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = EvaluateFeatureRequestMarshaller.Instance; options.ResponseUnmarshaller = EvaluateFeatureResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the EvaluateFeature operation. ///

/// /// Container for the necessary parameters to execute the EvaluateFeature operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndEvaluateFeature /// operation. /// REST API Reference for EvaluateFeature Operation public virtual IAsyncResult BeginEvaluateFeature(EvaluateFeatureRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = EvaluateFeatureRequestMarshaller.Instance; options.ResponseUnmarshaller = EvaluateFeatureResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the EvaluateFeature operation. ///

/// /// The IAsyncResult returned by the call to BeginEvaluateFeature. /// /// Returns a EvaluateFeatureResult from CloudWatchEvidently. /// REST API Reference for EvaluateFeature Operation public virtual EvaluateFeatureResponse EndEvaluateFeature(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetExperiment ///

/// 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. /// /// 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 GetExperimentResponse GetExperiment(GetExperimentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetExperimentRequestMarshaller.Instance; options.ResponseUnmarshaller = GetExperimentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetExperiment operation. ///

/// /// Container for the necessary parameters to execute the GetExperiment operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetExperiment /// operation. /// REST API Reference for GetExperiment Operation public virtual IAsyncResult BeginGetExperiment(GetExperimentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetExperimentRequestMarshaller.Instance; options.ResponseUnmarshaller = GetExperimentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetExperiment operation. ///

/// /// The IAsyncResult returned by the call to BeginGetExperiment. /// /// Returns a GetExperimentResult from CloudWatchEvidently. /// REST API Reference for GetExperiment Operation public virtual GetExperimentResponse EndGetExperiment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetExperimentResults ///

/// 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. /// /// 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 GetExperimentResultsResponse GetExperimentResults(GetExperimentResultsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetExperimentResultsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetExperimentResultsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetExperimentResults operation. ///

/// /// Container for the necessary parameters to execute the GetExperimentResults operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetExperimentResults /// operation. /// REST API Reference for GetExperimentResults Operation public virtual IAsyncResult BeginGetExperimentResults(GetExperimentResultsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetExperimentResultsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetExperimentResultsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetExperimentResults operation. ///

/// /// The IAsyncResult returned by the call to BeginGetExperimentResults. /// /// Returns a GetExperimentResultsResult from CloudWatchEvidently. /// REST API Reference for GetExperimentResults Operation public virtual GetExperimentResultsResponse EndGetExperimentResults(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetFeature ///

/// 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. /// /// 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 GetFeatureResponse GetFeature(GetFeatureRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetFeatureRequestMarshaller.Instance; options.ResponseUnmarshaller = GetFeatureResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetFeature operation. ///

/// /// Container for the necessary parameters to execute the GetFeature operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetFeature /// operation. /// REST API Reference for GetFeature Operation public virtual IAsyncResult BeginGetFeature(GetFeatureRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetFeatureRequestMarshaller.Instance; options.ResponseUnmarshaller = GetFeatureResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetFeature operation. ///

/// /// The IAsyncResult returned by the call to BeginGetFeature. /// /// Returns a GetFeatureResult from CloudWatchEvidently. /// REST API Reference for GetFeature Operation public virtual GetFeatureResponse EndGetFeature(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetLaunch ///

/// 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. /// /// 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 GetLaunchResponse GetLaunch(GetLaunchRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetLaunchRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLaunchResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetLaunch operation. ///

/// /// Container for the necessary parameters to execute the GetLaunch operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetLaunch /// operation. /// REST API Reference for GetLaunch Operation public virtual IAsyncResult BeginGetLaunch(GetLaunchRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetLaunchRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLaunchResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetLaunch operation. ///

/// /// The IAsyncResult returned by the call to BeginGetLaunch. /// /// Returns a GetLaunchResult from CloudWatchEvidently. /// REST API Reference for GetLaunch Operation public virtual GetLaunchResponse EndGetLaunch(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetProject ///

/// 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. /// /// 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 GetProjectResponse GetProject(GetProjectRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetProjectRequestMarshaller.Instance; options.ResponseUnmarshaller = GetProjectResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetProject operation. ///

/// /// Container for the necessary parameters to execute the GetProject operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetProject /// operation. /// REST API Reference for GetProject Operation public virtual IAsyncResult BeginGetProject(GetProjectRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetProjectRequestMarshaller.Instance; options.ResponseUnmarshaller = GetProjectResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetProject operation. ///

/// /// The IAsyncResult returned by the call to BeginGetProject. /// /// Returns a GetProjectResult from CloudWatchEvidently. /// REST API Reference for GetProject Operation public virtual GetProjectResponse EndGetProject(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetSegment ///

/// 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. /// /// 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 GetSegmentResponse GetSegment(GetSegmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetSegmentRequestMarshaller.Instance; options.ResponseUnmarshaller = GetSegmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetSegment operation. ///

/// /// Container for the necessary parameters to execute the GetSegment operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetSegment /// operation. /// REST API Reference for GetSegment Operation public virtual IAsyncResult BeginGetSegment(GetSegmentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetSegmentRequestMarshaller.Instance; options.ResponseUnmarshaller = GetSegmentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetSegment operation. ///

/// /// The IAsyncResult returned by the call to BeginGetSegment. /// /// Returns a GetSegmentResult from CloudWatchEvidently. /// REST API Reference for GetSegment Operation public virtual GetSegmentResponse EndGetSegment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListExperiments ///

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

/// Container for the necessary parameters to execute the ListExperiments service method. /// /// 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 ListExperimentsResponse ListExperiments(ListExperimentsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListExperimentsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListExperimentsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListExperiments operation. ///

/// /// Container for the necessary parameters to execute the ListExperiments operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListExperiments /// operation. /// REST API Reference for ListExperiments Operation public virtual IAsyncResult BeginListExperiments(ListExperimentsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListExperimentsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListExperimentsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListExperiments operation. ///

/// /// The IAsyncResult returned by the call to BeginListExperiments. /// /// Returns a ListExperimentsResult from CloudWatchEvidently. /// REST API Reference for ListExperiments Operation public virtual ListExperimentsResponse EndListExperiments(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListFeatures ///

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

/// Container for the necessary parameters to execute the ListFeatures service method. /// /// 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 ListFeaturesResponse ListFeatures(ListFeaturesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListFeaturesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListFeaturesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListFeatures operation. ///

/// /// Container for the necessary parameters to execute the ListFeatures operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListFeatures /// operation. /// REST API Reference for ListFeatures Operation public virtual IAsyncResult BeginListFeatures(ListFeaturesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListFeaturesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListFeaturesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListFeatures operation. ///

/// /// The IAsyncResult returned by the call to BeginListFeatures. /// /// Returns a ListFeaturesResult from CloudWatchEvidently. /// REST API Reference for ListFeatures Operation public virtual ListFeaturesResponse EndListFeatures(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListLaunches ///

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

/// Container for the necessary parameters to execute the ListLaunches service method. /// /// 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 ListLaunchesResponse ListLaunches(ListLaunchesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListLaunchesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLaunchesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListLaunches operation. ///

/// /// Container for the necessary parameters to execute the ListLaunches operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListLaunches /// operation. /// REST API Reference for ListLaunches Operation public virtual IAsyncResult BeginListLaunches(ListLaunchesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListLaunchesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLaunchesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListLaunches operation. ///

/// /// The IAsyncResult returned by the call to BeginListLaunches. /// /// Returns a ListLaunchesResult from CloudWatchEvidently. /// REST API Reference for ListLaunches Operation public virtual ListLaunchesResponse EndListLaunches(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListProjects ///

/// 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. /// /// 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 ListProjectsResponse ListProjects(ListProjectsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListProjectsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListProjectsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListProjects operation. ///

/// /// Container for the necessary parameters to execute the ListProjects operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListProjects /// operation. /// REST API Reference for ListProjects Operation public virtual IAsyncResult BeginListProjects(ListProjectsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListProjectsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListProjectsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListProjects operation. ///

/// /// The IAsyncResult returned by the call to BeginListProjects. /// /// Returns a ListProjectsResult from CloudWatchEvidently. /// REST API Reference for ListProjects Operation public virtual ListProjectsResponse EndListProjects(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListSegmentReferences ///

/// 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. /// /// 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 ListSegmentReferencesResponse ListSegmentReferences(ListSegmentReferencesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListSegmentReferencesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListSegmentReferencesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListSegmentReferences operation. ///

/// /// Container for the necessary parameters to execute the ListSegmentReferences operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListSegmentReferences /// operation. /// REST API Reference for ListSegmentReferences Operation public virtual IAsyncResult BeginListSegmentReferences(ListSegmentReferencesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListSegmentReferencesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListSegmentReferencesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListSegmentReferences operation. ///

/// /// The IAsyncResult returned by the call to BeginListSegmentReferences. /// /// Returns a ListSegmentReferencesResult from CloudWatchEvidently. /// REST API Reference for ListSegmentReferences Operation public virtual ListSegmentReferencesResponse EndListSegmentReferences(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListSegments ///

/// 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. /// /// 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 ListSegmentsResponse ListSegments(ListSegmentsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListSegmentsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListSegmentsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListSegments operation. ///

/// /// Container for the necessary parameters to execute the ListSegments operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListSegments /// operation. /// REST API Reference for ListSegments Operation public virtual IAsyncResult BeginListSegments(ListSegmentsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListSegmentsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListSegmentsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListSegments operation. ///

/// /// The IAsyncResult returned by the call to BeginListSegments. /// /// Returns a ListSegmentsResult from CloudWatchEvidently. /// REST API Reference for ListSegments Operation public virtual ListSegmentsResponse EndListSegments(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListTagsForResource ///

/// Displays the tags associated with an Evidently resource. ///

/// Container for the necessary parameters to execute the ListTagsForResource service method. /// /// 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 ListTagsForResourceResponse ListTagsForResource(ListTagsForResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListTagsForResource operation. ///

/// /// Container for the necessary parameters to execute the ListTagsForResource operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListTagsForResource /// operation. /// REST API Reference for ListTagsForResource Operation public virtual IAsyncResult BeginListTagsForResource(ListTagsForResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListTagsForResource operation. ///

/// /// The IAsyncResult returned by the call to BeginListTagsForResource. /// /// Returns a ListTagsForResourceResult from CloudWatchEvidently. /// REST API Reference for ListTagsForResource Operation public virtual ListTagsForResourceResponse EndListTagsForResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region PutProjectEvents ///

/// 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. /// /// 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 PutProjectEventsResponse PutProjectEvents(PutProjectEventsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = PutProjectEventsRequestMarshaller.Instance; options.ResponseUnmarshaller = PutProjectEventsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the PutProjectEvents operation. ///

/// /// Container for the necessary parameters to execute the PutProjectEvents operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndPutProjectEvents /// operation. /// REST API Reference for PutProjectEvents Operation public virtual IAsyncResult BeginPutProjectEvents(PutProjectEventsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = PutProjectEventsRequestMarshaller.Instance; options.ResponseUnmarshaller = PutProjectEventsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the PutProjectEvents operation. ///

/// /// The IAsyncResult returned by the call to BeginPutProjectEvents. /// /// Returns a PutProjectEventsResult from CloudWatchEvidently. /// REST API Reference for PutProjectEvents Operation public virtual PutProjectEventsResponse EndPutProjectEvents(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StartExperiment ///

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

/// Container for the necessary parameters to execute the StartExperiment service method. /// /// 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 StartExperimentResponse StartExperiment(StartExperimentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartExperimentRequestMarshaller.Instance; options.ResponseUnmarshaller = StartExperimentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StartExperiment operation. ///

/// /// Container for the necessary parameters to execute the StartExperiment operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartExperiment /// operation. /// REST API Reference for StartExperiment Operation public virtual IAsyncResult BeginStartExperiment(StartExperimentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StartExperimentRequestMarshaller.Instance; options.ResponseUnmarshaller = StartExperimentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StartExperiment operation. ///

/// /// The IAsyncResult returned by the call to BeginStartExperiment. /// /// Returns a StartExperimentResult from CloudWatchEvidently. /// REST API Reference for StartExperiment Operation public virtual StartExperimentResponse EndStartExperiment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StartLaunch ///

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

/// Container for the necessary parameters to execute the StartLaunch service method. /// /// 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 StartLaunchResponse StartLaunch(StartLaunchRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartLaunchRequestMarshaller.Instance; options.ResponseUnmarshaller = StartLaunchResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StartLaunch operation. ///

/// /// Container for the necessary parameters to execute the StartLaunch operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartLaunch /// operation. /// REST API Reference for StartLaunch Operation public virtual IAsyncResult BeginStartLaunch(StartLaunchRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StartLaunchRequestMarshaller.Instance; options.ResponseUnmarshaller = StartLaunchResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StartLaunch operation. ///

/// /// The IAsyncResult returned by the call to BeginStartLaunch. /// /// Returns a StartLaunchResult from CloudWatchEvidently. /// REST API Reference for StartLaunch Operation public virtual StartLaunchResponse EndStartLaunch(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StopExperiment ///

/// 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. /// /// 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 StopExperimentResponse StopExperiment(StopExperimentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StopExperimentRequestMarshaller.Instance; options.ResponseUnmarshaller = StopExperimentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StopExperiment operation. ///

/// /// Container for the necessary parameters to execute the StopExperiment operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStopExperiment /// operation. /// REST API Reference for StopExperiment Operation public virtual IAsyncResult BeginStopExperiment(StopExperimentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StopExperimentRequestMarshaller.Instance; options.ResponseUnmarshaller = StopExperimentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StopExperiment operation. ///

/// /// The IAsyncResult returned by the call to BeginStopExperiment. /// /// Returns a StopExperimentResult from CloudWatchEvidently. /// REST API Reference for StopExperiment Operation public virtual StopExperimentResponse EndStopExperiment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StopLaunch ///

/// 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. /// /// 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 StopLaunchResponse StopLaunch(StopLaunchRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StopLaunchRequestMarshaller.Instance; options.ResponseUnmarshaller = StopLaunchResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StopLaunch operation. ///

/// /// Container for the necessary parameters to execute the StopLaunch operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStopLaunch /// operation. /// REST API Reference for StopLaunch Operation public virtual IAsyncResult BeginStopLaunch(StopLaunchRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StopLaunchRequestMarshaller.Instance; options.ResponseUnmarshaller = StopLaunchResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StopLaunch operation. ///

/// /// The IAsyncResult returned by the call to BeginStopLaunch. /// /// Returns a StopLaunchResult from CloudWatchEvidently. /// REST API Reference for StopLaunch Operation public virtual StopLaunchResponse EndStopLaunch(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region TagResource ///

/// 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. /// /// 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 TagResourceResponse TagResource(TagResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = TagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the TagResource operation. ///

/// /// Container for the necessary parameters to execute the TagResource operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndTagResource /// operation. /// REST API Reference for TagResource Operation public virtual IAsyncResult BeginTagResource(TagResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = TagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the TagResource operation. ///

/// /// The IAsyncResult returned by the call to BeginTagResource. /// /// Returns a TagResourceResult from CloudWatchEvidently. /// REST API Reference for TagResource Operation public virtual TagResourceResponse EndTagResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region TestSegmentPattern ///

/// 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. /// /// 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 TestSegmentPatternResponse TestSegmentPattern(TestSegmentPatternRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = TestSegmentPatternRequestMarshaller.Instance; options.ResponseUnmarshaller = TestSegmentPatternResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the TestSegmentPattern operation. ///

/// /// Container for the necessary parameters to execute the TestSegmentPattern operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndTestSegmentPattern /// operation. /// REST API Reference for TestSegmentPattern Operation public virtual IAsyncResult BeginTestSegmentPattern(TestSegmentPatternRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = TestSegmentPatternRequestMarshaller.Instance; options.ResponseUnmarshaller = TestSegmentPatternResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the TestSegmentPattern operation. ///

/// /// The IAsyncResult returned by the call to BeginTestSegmentPattern. /// /// Returns a TestSegmentPatternResult from CloudWatchEvidently. /// REST API Reference for TestSegmentPattern Operation public virtual TestSegmentPatternResponse EndTestSegmentPattern(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UntagResource ///

/// Removes one or more tags from the specified resource. ///

/// Container for the necessary parameters to execute the UntagResource service method. /// /// 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 UntagResourceResponse UntagResource(UntagResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UntagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UntagResource operation. ///

/// /// Container for the necessary parameters to execute the UntagResource operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUntagResource /// operation. /// REST API Reference for UntagResource Operation public virtual IAsyncResult BeginUntagResource(UntagResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UntagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UntagResource operation. ///

/// /// The IAsyncResult returned by the call to BeginUntagResource. /// /// Returns a UntagResourceResult from CloudWatchEvidently. /// REST API Reference for UntagResource Operation public virtual UntagResourceResponse EndUntagResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateExperiment ///

/// 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. /// /// 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 UpdateExperimentResponse UpdateExperiment(UpdateExperimentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateExperimentRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateExperimentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateExperiment operation. ///

/// /// Container for the necessary parameters to execute the UpdateExperiment operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateExperiment /// operation. /// REST API Reference for UpdateExperiment Operation public virtual IAsyncResult BeginUpdateExperiment(UpdateExperimentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateExperimentRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateExperimentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateExperiment operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateExperiment. /// /// Returns a UpdateExperimentResult from CloudWatchEvidently. /// REST API Reference for UpdateExperiment Operation public virtual UpdateExperimentResponse EndUpdateExperiment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateFeature ///

/// 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. /// /// 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 UpdateFeatureResponse UpdateFeature(UpdateFeatureRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateFeatureRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateFeatureResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateFeature operation. ///

/// /// Container for the necessary parameters to execute the UpdateFeature operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateFeature /// operation. /// REST API Reference for UpdateFeature Operation public virtual IAsyncResult BeginUpdateFeature(UpdateFeatureRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateFeatureRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateFeatureResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateFeature operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateFeature. /// /// Returns a UpdateFeatureResult from CloudWatchEvidently. /// REST API Reference for UpdateFeature Operation public virtual UpdateFeatureResponse EndUpdateFeature(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateLaunch ///

/// 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. /// /// 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 UpdateLaunchResponse UpdateLaunch(UpdateLaunchRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateLaunchRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateLaunchResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateLaunch operation. ///

/// /// Container for the necessary parameters to execute the UpdateLaunch operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateLaunch /// operation. /// REST API Reference for UpdateLaunch Operation public virtual IAsyncResult BeginUpdateLaunch(UpdateLaunchRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateLaunchRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateLaunchResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateLaunch operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateLaunch. /// /// Returns a UpdateLaunchResult from CloudWatchEvidently. /// REST API Reference for UpdateLaunch Operation public virtual UpdateLaunchResponse EndUpdateLaunch(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateProject ///

/// 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. /// /// 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 UpdateProjectResponse UpdateProject(UpdateProjectRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateProjectRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateProjectResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateProject operation. ///

/// /// Container for the necessary parameters to execute the UpdateProject operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateProject /// operation. /// REST API Reference for UpdateProject Operation public virtual IAsyncResult BeginUpdateProject(UpdateProjectRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateProjectRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateProjectResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateProject operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateProject. /// /// Returns a UpdateProjectResult from CloudWatchEvidently. /// REST API Reference for UpdateProject Operation public virtual UpdateProjectResponse EndUpdateProject(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateProjectDataDelivery ///

/// 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. /// /// 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 UpdateProjectDataDeliveryResponse UpdateProjectDataDelivery(UpdateProjectDataDeliveryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateProjectDataDeliveryRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateProjectDataDeliveryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateProjectDataDelivery operation. ///

/// /// Container for the necessary parameters to execute the UpdateProjectDataDelivery operation on AmazonCloudWatchEvidentlyClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateProjectDataDelivery /// operation. /// REST API Reference for UpdateProjectDataDelivery Operation public virtual IAsyncResult BeginUpdateProjectDataDelivery(UpdateProjectDataDeliveryRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateProjectDataDeliveryRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateProjectDataDeliveryResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateProjectDataDelivery operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateProjectDataDelivery. /// /// Returns a UpdateProjectDataDeliveryResult from CloudWatchEvidently. /// REST API Reference for UpdateProjectDataDelivery Operation public virtual UpdateProjectDataDeliveryResponse EndUpdateProjectDataDelivery(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion } }