/* * 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 wellarchitected-2020-03-31.normal.json service model. */ using System; using System.Collections.Generic; using System.Net; using Amazon.WellArchitected.Model; using Amazon.WellArchitected.Model.Internal.MarshallTransformations; using Amazon.WellArchitected.Internal; using Amazon.Runtime; using Amazon.Runtime.Internal; using Amazon.Runtime.Internal.Auth; using Amazon.Runtime.Internal.Transform; namespace Amazon.WellArchitected { ///

/// Implementation for accessing WellArchitected /// /// Well-Architected Tool /// /// This is the Well-Architected Tool API Reference. The WA Tool API provides programmatic /// access to the Well-Architected /// Tool in the Amazon Web /// Services Management Console. For information about the Well-Architected Tool, /// see the Well-Architected /// Tool User Guide. /// ///

public partial class AmazonWellArchitectedClient : AmazonServiceClient, IAmazonWellArchitected { private static IServiceMetadata serviceMetadata = new AmazonWellArchitectedMetadata(); #if BCL45 || AWS_ASYNC_ENUMERABLES_API private IWellArchitectedPaginatorFactory _paginators; ///

/// Paginators for the service ///

public IWellArchitectedPaginatorFactory Paginators { get { if (this._paginators == null) { this._paginators = new WellArchitectedPaginatorFactory(this); } return this._paginators; } } #endif #region Constructors ///

/// Constructs AmazonWellArchitectedClient 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 AmazonWellArchitectedClient() : base(FallbackCredentialsFactory.GetCredentials(), new AmazonWellArchitectedConfig()) { } ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

/// The region to connect. public AmazonWellArchitectedClient(RegionEndpoint region) : base(FallbackCredentialsFactory.GetCredentials(), new AmazonWellArchitectedConfig{RegionEndpoint = region}) { } ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

/// The AmazonWellArchitectedClient Configuration Object public AmazonWellArchitectedClient(AmazonWellArchitectedConfig config) : base(FallbackCredentialsFactory.GetCredentials(config), config){} ///

/// Constructs AmazonWellArchitectedClient with AWS Credentials ///

/// AWS Credentials public AmazonWellArchitectedClient(AWSCredentials credentials) : this(credentials, new AmazonWellArchitectedConfig()) { } ///

/// Constructs AmazonWellArchitectedClient with AWS Credentials ///

/// AWS Credentials /// The region to connect. public AmazonWellArchitectedClient(AWSCredentials credentials, RegionEndpoint region) : this(credentials, new AmazonWellArchitectedConfig{RegionEndpoint = region}) { } ///

/// Constructs AmazonWellArchitectedClient with AWS Credentials and an /// AmazonWellArchitectedClient Configuration object. ///

/// AWS Credentials /// The AmazonWellArchitectedClient Configuration Object public AmazonWellArchitectedClient(AWSCredentials credentials, AmazonWellArchitectedConfig clientConfig) : base(credentials, clientConfig) { } ///

/// Constructs AmazonWellArchitectedClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key public AmazonWellArchitectedClient(string awsAccessKeyId, string awsSecretAccessKey) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonWellArchitectedConfig()) { } ///

/// Constructs AmazonWellArchitectedClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// The region to connect. public AmazonWellArchitectedClient(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonWellArchitectedConfig() {RegionEndpoint=region}) { } ///

/// Constructs AmazonWellArchitectedClient with AWS Access Key ID, AWS Secret Key and an /// AmazonWellArchitectedClient Configuration object. ///

/// AWS Access Key ID /// AWS Secret Access Key /// The AmazonWellArchitectedClient Configuration Object public AmazonWellArchitectedClient(string awsAccessKeyId, string awsSecretAccessKey, AmazonWellArchitectedConfig clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, clientConfig) { } ///

/// Constructs AmazonWellArchitectedClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token public AmazonWellArchitectedClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonWellArchitectedConfig()) { } ///

/// Constructs AmazonWellArchitectedClient 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 AmazonWellArchitectedClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonWellArchitectedConfig{RegionEndpoint = region}) { } ///

/// Constructs AmazonWellArchitectedClient with AWS Access Key ID, AWS Secret Key and an /// AmazonWellArchitectedClient Configuration object. ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The AmazonWellArchitectedClient Configuration Object public AmazonWellArchitectedClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonWellArchitectedConfig 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 AmazonWellArchitectedEndpointResolver()); } ///

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

/// Associate a lens to a workload. /// /// /// /// Up to 10 lenses can be associated with a workload in a single API operation. A maximum /// of 20 lenses can be associated with a workload. /// /// /// /// Disclaimer /// /// /// /// By accessing and/or applying custom lenses created by another Amazon Web Services /// user or account, you acknowledge that custom lenses created by other users and shared /// with you are Third Party Content as defined in the Amazon Web Services Customer Agreement. /// /// /// ///

/// Container for the necessary parameters to execute the AssociateLenses service method. /// /// The response from the AssociateLenses service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for AssociateLenses Operation public virtual AssociateLensesResponse AssociateLenses(AssociateLensesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateLensesRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateLensesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the AssociateLenses operation on AmazonWellArchitectedClient. /// 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 EndAssociateLenses /// operation. /// REST API Reference for AssociateLenses Operation public virtual IAsyncResult BeginAssociateLenses(AssociateLensesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateLensesRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateLensesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginAssociateLenses. /// /// Returns a AssociateLensesResult from WellArchitected. /// REST API Reference for AssociateLenses Operation public virtual AssociateLensesResponse EndAssociateLenses(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region AssociateProfiles ///

/// Associate a profile with a workload. ///

/// Container for the necessary parameters to execute the AssociateProfiles service method. /// /// The response from the AssociateProfiles service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for AssociateProfiles Operation public virtual AssociateProfilesResponse AssociateProfiles(AssociateProfilesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateProfilesRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateProfilesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the AssociateProfiles operation on AmazonWellArchitectedClient. /// 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 EndAssociateProfiles /// operation. /// REST API Reference for AssociateProfiles Operation public virtual IAsyncResult BeginAssociateProfiles(AssociateProfilesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateProfilesRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateProfilesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginAssociateProfiles. /// /// Returns a AssociateProfilesResult from WellArchitected. /// REST API Reference for AssociateProfiles Operation public virtual AssociateProfilesResponse EndAssociateProfiles(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateLensShare ///

/// Create a lens share. /// /// /// /// The owner of a lens can share it with other Amazon Web Services accounts, users, an /// organization, and organizational units (OUs) in the same Amazon Web Services Region. /// Lenses provided by Amazon Web Services (Amazon Web Services Official Content) cannot /// be shared. /// /// /// /// Shared access to a lens is not removed until the lens invitation is deleted. /// /// /// /// If you share a lens with an organization or OU, all accounts in the organization or /// OU are granted access to the lens. /// /// /// /// For more information, see Sharing /// a custom lens in the Well-Architected Tool User Guide. /// /// /// /// Disclaimer /// /// /// /// By sharing your custom lenses with other Amazon Web Services accounts, you acknowledge /// that Amazon Web Services will make your custom lenses available to those other accounts. /// Those other accounts may continue to access and use your shared custom lenses even /// if you delete the custom lenses from your own Amazon Web Services account or terminate /// your Amazon Web Services account. /// /// ///

/// Container for the necessary parameters to execute the CreateLensShare service method. /// /// The response from the CreateLensShare service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// The user has reached their resource quota. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for CreateLensShare Operation public virtual CreateLensShareResponse CreateLensShare(CreateLensShareRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLensShareRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLensShareResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateLensShare operation on AmazonWellArchitectedClient. /// 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 EndCreateLensShare /// operation. /// REST API Reference for CreateLensShare Operation public virtual IAsyncResult BeginCreateLensShare(CreateLensShareRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLensShareRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLensShareResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateLensShare. /// /// Returns a CreateLensShareResult from WellArchitected. /// REST API Reference for CreateLensShare Operation public virtual CreateLensShareResponse EndCreateLensShare(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateLensVersion ///

/// Create a new lens version. /// /// /// /// A lens can have up to 100 versions. /// /// /// /// Use this operation to publish a new lens version after you have imported a lens. The /// LensAlias is used to identify the lens to be published. The owner of /// a lens can share the lens with other Amazon Web Services accounts and users in the /// same Amazon Web Services Region. Only the owner of a lens can delete it. /// ///

/// Container for the necessary parameters to execute the CreateLensVersion service method. /// /// The response from the CreateLensVersion service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// The user has reached their resource quota. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for CreateLensVersion Operation public virtual CreateLensVersionResponse CreateLensVersion(CreateLensVersionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLensVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLensVersionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateLensVersion operation on AmazonWellArchitectedClient. /// 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 EndCreateLensVersion /// operation. /// REST API Reference for CreateLensVersion Operation public virtual IAsyncResult BeginCreateLensVersion(CreateLensVersionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLensVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLensVersionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateLensVersion. /// /// Returns a CreateLensVersionResult from WellArchitected. /// REST API Reference for CreateLensVersion Operation public virtual CreateLensVersionResponse EndCreateLensVersion(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateMilestone ///

/// Create a milestone for an existing workload. ///

/// Container for the necessary parameters to execute the CreateMilestone service method. /// /// The response from the CreateMilestone service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// The user has reached their resource quota. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for CreateMilestone Operation public virtual CreateMilestoneResponse CreateMilestone(CreateMilestoneRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateMilestoneRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateMilestoneResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateMilestone operation on AmazonWellArchitectedClient. /// 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 EndCreateMilestone /// operation. /// REST API Reference for CreateMilestone Operation public virtual IAsyncResult BeginCreateMilestone(CreateMilestoneRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateMilestoneRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateMilestoneResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateMilestone. /// /// Returns a CreateMilestoneResult from WellArchitected. /// REST API Reference for CreateMilestone Operation public virtual CreateMilestoneResponse EndCreateMilestone(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateProfile ///

/// Create a profile. ///

/// Container for the necessary parameters to execute the CreateProfile service method. /// /// The response from the CreateProfile service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The user has reached their resource quota. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for CreateProfile Operation public virtual CreateProfileResponse CreateProfile(CreateProfileRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateProfileResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateProfile operation on AmazonWellArchitectedClient. /// 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 EndCreateProfile /// operation. /// REST API Reference for CreateProfile Operation public virtual IAsyncResult BeginCreateProfile(CreateProfileRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateProfileResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateProfile. /// /// Returns a CreateProfileResult from WellArchitected. /// REST API Reference for CreateProfile Operation public virtual CreateProfileResponse EndCreateProfile(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateProfileShare ///

/// Create a profile share. ///

/// Container for the necessary parameters to execute the CreateProfileShare service method. /// /// The response from the CreateProfileShare service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// The user has reached their resource quota. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for CreateProfileShare Operation public virtual CreateProfileShareResponse CreateProfileShare(CreateProfileShareRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateProfileShareRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateProfileShareResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateProfileShare operation on AmazonWellArchitectedClient. /// 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 EndCreateProfileShare /// operation. /// REST API Reference for CreateProfileShare Operation public virtual IAsyncResult BeginCreateProfileShare(CreateProfileShareRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateProfileShareRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateProfileShareResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateProfileShare. /// /// Returns a CreateProfileShareResult from WellArchitected. /// REST API Reference for CreateProfileShare Operation public virtual CreateProfileShareResponse EndCreateProfileShare(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateWorkload ///

/// Create a new workload. /// /// /// /// The owner of a workload can share the workload with other Amazon Web Services accounts, /// users, an organization, and organizational units (OUs) in the same Amazon Web Services /// Region. Only the owner of a workload can delete it. /// /// /// /// For more information, see Defining /// a Workload in the Well-Architected Tool User Guide. /// /// /// /// Either AwsRegions, NonAwsRegions, or both must be specified /// when creating a workload. /// /// /// /// You also must specify ReviewOwner, even though the parameter is listed /// as not being required in the following section. /// /// ///

/// Container for the necessary parameters to execute the CreateWorkload service method. /// /// The response from the CreateWorkload service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// The user has reached their resource quota. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for CreateWorkload Operation public virtual CreateWorkloadResponse CreateWorkload(CreateWorkloadRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateWorkloadRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateWorkloadResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateWorkload operation on AmazonWellArchitectedClient. /// 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 EndCreateWorkload /// operation. /// REST API Reference for CreateWorkload Operation public virtual IAsyncResult BeginCreateWorkload(CreateWorkloadRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateWorkloadRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateWorkloadResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateWorkload. /// /// Returns a CreateWorkloadResult from WellArchitected. /// REST API Reference for CreateWorkload Operation public virtual CreateWorkloadResponse EndCreateWorkload(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateWorkloadShare ///

/// Create a workload share. /// /// /// /// The owner of a workload can share it with other Amazon Web Services accounts and users /// in the same Amazon Web Services Region. Shared access to a workload is not removed /// until the workload invitation is deleted. /// /// /// /// If you share a workload with an organization or OU, all accounts in the organization /// or OU are granted access to the workload. /// /// /// /// For more information, see Sharing /// a workload in the Well-Architected Tool User Guide. /// ///

/// Container for the necessary parameters to execute the CreateWorkloadShare service method. /// /// The response from the CreateWorkloadShare service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// The user has reached their resource quota. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for CreateWorkloadShare Operation public virtual CreateWorkloadShareResponse CreateWorkloadShare(CreateWorkloadShareRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateWorkloadShareRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateWorkloadShareResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the CreateWorkloadShare operation on AmazonWellArchitectedClient. /// 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 EndCreateWorkloadShare /// operation. /// REST API Reference for CreateWorkloadShare Operation public virtual IAsyncResult BeginCreateWorkloadShare(CreateWorkloadShareRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateWorkloadShareRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateWorkloadShareResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginCreateWorkloadShare. /// /// Returns a CreateWorkloadShareResult from WellArchitected. /// REST API Reference for CreateWorkloadShare Operation public virtual CreateWorkloadShareResponse EndCreateWorkloadShare(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteLens ///

/// Delete an existing lens. /// /// /// /// Only the owner of a lens can delete it. After the lens is deleted, Amazon Web Services /// accounts and users that you shared the lens with can continue to use it, but they /// will no longer be able to apply it to new workloads. /// /// /// /// Disclaimer /// /// /// /// By sharing your custom lenses with other Amazon Web Services accounts, you acknowledge /// that Amazon Web Services will make your custom lenses available to those other accounts. /// Those other accounts may continue to access and use your shared custom lenses even /// if you delete the custom lenses from your own Amazon Web Services account or terminate /// your Amazon Web Services account. /// /// ///

/// Container for the necessary parameters to execute the DeleteLens service method. /// /// The response from the DeleteLens service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for DeleteLens Operation public virtual DeleteLensResponse DeleteLens(DeleteLensRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteLensRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteLensResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DeleteLens operation on AmazonWellArchitectedClient. /// 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 EndDeleteLens /// operation. /// REST API Reference for DeleteLens Operation public virtual IAsyncResult BeginDeleteLens(DeleteLensRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteLensRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteLensResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteLens. /// /// Returns a DeleteLensResult from WellArchitected. /// REST API Reference for DeleteLens Operation public virtual DeleteLensResponse EndDeleteLens(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteLensShare ///

/// Delete a lens share. /// /// /// /// After the lens share is deleted, Amazon Web Services accounts, users, organizations, /// and organizational units (OUs) that you shared the lens with can continue to use it, /// but they will no longer be able to apply it to new workloads. /// /// /// /// Disclaimer /// /// /// /// By sharing your custom lenses with other Amazon Web Services accounts, you acknowledge /// that Amazon Web Services will make your custom lenses available to those other accounts. /// Those other accounts may continue to access and use your shared custom lenses even /// if you delete the custom lenses from your own Amazon Web Services account or terminate /// your Amazon Web Services account. /// /// ///

/// Container for the necessary parameters to execute the DeleteLensShare service method. /// /// The response from the DeleteLensShare service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for DeleteLensShare Operation public virtual DeleteLensShareResponse DeleteLensShare(DeleteLensShareRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteLensShareRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteLensShareResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DeleteLensShare operation on AmazonWellArchitectedClient. /// 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 EndDeleteLensShare /// operation. /// REST API Reference for DeleteLensShare Operation public virtual IAsyncResult BeginDeleteLensShare(DeleteLensShareRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteLensShareRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteLensShareResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteLensShare. /// /// Returns a DeleteLensShareResult from WellArchitected. /// REST API Reference for DeleteLensShare Operation public virtual DeleteLensShareResponse EndDeleteLensShare(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteProfile ///

/// Delete a profile. /// /// /// /// Disclaimer /// /// /// /// By sharing your profile with other Amazon Web Services accounts, you acknowledge that /// Amazon Web Services will make your profile available to those other accounts. Those /// other accounts may continue to access and use your shared profile even if you delete /// the profile from your own Amazon Web Services account or terminate your Amazon Web /// Services account. /// /// ///

/// Container for the necessary parameters to execute the DeleteProfile service method. /// /// The response from the DeleteProfile service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for DeleteProfile Operation public virtual DeleteProfileResponse DeleteProfile(DeleteProfileRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteProfileResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DeleteProfile operation on AmazonWellArchitectedClient. /// 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 EndDeleteProfile /// operation. /// REST API Reference for DeleteProfile Operation public virtual IAsyncResult BeginDeleteProfile(DeleteProfileRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteProfileResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteProfile. /// /// Returns a DeleteProfileResult from WellArchitected. /// REST API Reference for DeleteProfile Operation public virtual DeleteProfileResponse EndDeleteProfile(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteProfileShare ///

/// Delete a profile share. ///

/// Container for the necessary parameters to execute the DeleteProfileShare service method. /// /// The response from the DeleteProfileShare service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for DeleteProfileShare Operation public virtual DeleteProfileShareResponse DeleteProfileShare(DeleteProfileShareRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteProfileShareRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteProfileShareResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DeleteProfileShare operation on AmazonWellArchitectedClient. /// 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 EndDeleteProfileShare /// operation. /// REST API Reference for DeleteProfileShare Operation public virtual IAsyncResult BeginDeleteProfileShare(DeleteProfileShareRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteProfileShareRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteProfileShareResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteProfileShare. /// /// Returns a DeleteProfileShareResult from WellArchitected. /// REST API Reference for DeleteProfileShare Operation public virtual DeleteProfileShareResponse EndDeleteProfileShare(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteWorkload ///

/// Delete an existing workload. ///

/// Container for the necessary parameters to execute the DeleteWorkload service method. /// /// The response from the DeleteWorkload service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for DeleteWorkload Operation public virtual DeleteWorkloadResponse DeleteWorkload(DeleteWorkloadRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteWorkloadRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteWorkloadResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DeleteWorkload operation on AmazonWellArchitectedClient. /// 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 EndDeleteWorkload /// operation. /// REST API Reference for DeleteWorkload Operation public virtual IAsyncResult BeginDeleteWorkload(DeleteWorkloadRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteWorkloadRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteWorkloadResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteWorkload. /// /// Returns a DeleteWorkloadResult from WellArchitected. /// REST API Reference for DeleteWorkload Operation public virtual DeleteWorkloadResponse EndDeleteWorkload(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteWorkloadShare ///

/// Delete a workload share. ///

/// Container for the necessary parameters to execute the DeleteWorkloadShare service method. /// /// The response from the DeleteWorkloadShare service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for DeleteWorkloadShare Operation public virtual DeleteWorkloadShareResponse DeleteWorkloadShare(DeleteWorkloadShareRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteWorkloadShareRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteWorkloadShareResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DeleteWorkloadShare operation on AmazonWellArchitectedClient. /// 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 EndDeleteWorkloadShare /// operation. /// REST API Reference for DeleteWorkloadShare Operation public virtual IAsyncResult BeginDeleteWorkloadShare(DeleteWorkloadShareRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteWorkloadShareRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteWorkloadShareResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDeleteWorkloadShare. /// /// Returns a DeleteWorkloadShareResult from WellArchitected. /// REST API Reference for DeleteWorkloadShare Operation public virtual DeleteWorkloadShareResponse EndDeleteWorkloadShare(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DisassociateLenses ///

/// Disassociate a lens from a workload. /// /// /// /// Up to 10 lenses can be disassociated from a workload in a single API operation. /// /// /// /// The Amazon Web Services Well-Architected Framework lens (wellarchitected) /// cannot be removed from a workload. /// /// ///

/// Container for the necessary parameters to execute the DisassociateLenses service method. /// /// The response from the DisassociateLenses service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for DisassociateLenses Operation public virtual DisassociateLensesResponse DisassociateLenses(DisassociateLensesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DisassociateLensesRequestMarshaller.Instance; options.ResponseUnmarshaller = DisassociateLensesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DisassociateLenses operation on AmazonWellArchitectedClient. /// 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 EndDisassociateLenses /// operation. /// REST API Reference for DisassociateLenses Operation public virtual IAsyncResult BeginDisassociateLenses(DisassociateLensesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DisassociateLensesRequestMarshaller.Instance; options.ResponseUnmarshaller = DisassociateLensesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDisassociateLenses. /// /// Returns a DisassociateLensesResult from WellArchitected. /// REST API Reference for DisassociateLenses Operation public virtual DisassociateLensesResponse EndDisassociateLenses(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DisassociateProfiles ///

/// Disassociate a profile from a workload. ///

/// Container for the necessary parameters to execute the DisassociateProfiles service method. /// /// The response from the DisassociateProfiles service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for DisassociateProfiles Operation public virtual DisassociateProfilesResponse DisassociateProfiles(DisassociateProfilesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DisassociateProfilesRequestMarshaller.Instance; options.ResponseUnmarshaller = DisassociateProfilesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the DisassociateProfiles operation on AmazonWellArchitectedClient. /// 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 EndDisassociateProfiles /// operation. /// REST API Reference for DisassociateProfiles Operation public virtual IAsyncResult BeginDisassociateProfiles(DisassociateProfilesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DisassociateProfilesRequestMarshaller.Instance; options.ResponseUnmarshaller = DisassociateProfilesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginDisassociateProfiles. /// /// Returns a DisassociateProfilesResult from WellArchitected. /// REST API Reference for DisassociateProfiles Operation public virtual DisassociateProfilesResponse EndDisassociateProfiles(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ExportLens ///

/// Export an existing lens. /// /// /// /// Only the owner of a lens can export it. Lenses provided by Amazon Web Services (Amazon /// Web Services Official Content) cannot be exported. /// /// /// /// Lenses are defined in JSON. For more information, see JSON /// format specification in the Well-Architected Tool User Guide. /// /// /// /// Disclaimer /// /// /// /// Do not include or gather personal identifiable information (PII) of end users or other /// identifiable individuals in or via your custom lenses. If your custom lens or those /// shared with you and used in your account do include or collect PII you are responsible /// for: ensuring that the included PII is processed in accordance with applicable law, /// providing adequate privacy notices, and obtaining necessary consents for processing /// such data. /// /// ///

/// Container for the necessary parameters to execute the ExportLens service method. /// /// The response from the ExportLens service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for ExportLens Operation public virtual ExportLensResponse ExportLens(ExportLensRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ExportLensRequestMarshaller.Instance; options.ResponseUnmarshaller = ExportLensResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ExportLens operation on AmazonWellArchitectedClient. /// 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 EndExportLens /// operation. /// REST API Reference for ExportLens Operation public virtual IAsyncResult BeginExportLens(ExportLensRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ExportLensRequestMarshaller.Instance; options.ResponseUnmarshaller = ExportLensResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginExportLens. /// /// Returns a ExportLensResult from WellArchitected. /// REST API Reference for ExportLens Operation public virtual ExportLensResponse EndExportLens(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetAnswer ///

/// Get the answer to a specific question in a workload review. ///

/// Container for the necessary parameters to execute the GetAnswer service method. /// /// The response from the GetAnswer service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for GetAnswer Operation public virtual GetAnswerResponse GetAnswer(GetAnswerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetAnswerRequestMarshaller.Instance; options.ResponseUnmarshaller = GetAnswerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetAnswer operation on AmazonWellArchitectedClient. /// 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 EndGetAnswer /// operation. /// REST API Reference for GetAnswer Operation public virtual IAsyncResult BeginGetAnswer(GetAnswerRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetAnswerRequestMarshaller.Instance; options.ResponseUnmarshaller = GetAnswerResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetAnswer. /// /// Returns a GetAnswerResult from WellArchitected. /// REST API Reference for GetAnswer Operation public virtual GetAnswerResponse EndGetAnswer(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetConsolidatedReport ///

/// Get a consolidated report of your workloads. /// /// /// /// You can optionally choose to include workloads that have been shared with you. /// ///

/// Container for the necessary parameters to execute the GetConsolidatedReport service method. /// /// The response from the GetConsolidatedReport service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for GetConsolidatedReport Operation public virtual GetConsolidatedReportResponse GetConsolidatedReport(GetConsolidatedReportRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetConsolidatedReportRequestMarshaller.Instance; options.ResponseUnmarshaller = GetConsolidatedReportResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetConsolidatedReport operation on AmazonWellArchitectedClient. /// 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 EndGetConsolidatedReport /// operation. /// REST API Reference for GetConsolidatedReport Operation public virtual IAsyncResult BeginGetConsolidatedReport(GetConsolidatedReportRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetConsolidatedReportRequestMarshaller.Instance; options.ResponseUnmarshaller = GetConsolidatedReportResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetConsolidatedReport. /// /// Returns a GetConsolidatedReportResult from WellArchitected. /// REST API Reference for GetConsolidatedReport Operation public virtual GetConsolidatedReportResponse EndGetConsolidatedReport(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetLens ///

/// Get an existing lens. ///

/// Container for the necessary parameters to execute the GetLens service method. /// /// The response from the GetLens service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for GetLens Operation public virtual GetLensResponse GetLens(GetLensRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetLensRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLensResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetLens operation on AmazonWellArchitectedClient. /// 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 EndGetLens /// operation. /// REST API Reference for GetLens Operation public virtual IAsyncResult BeginGetLens(GetLensRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetLensRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLensResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetLens. /// /// Returns a GetLensResult from WellArchitected. /// REST API Reference for GetLens Operation public virtual GetLensResponse EndGetLens(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetLensReview ///

/// Get lens review. ///

/// Container for the necessary parameters to execute the GetLensReview service method. /// /// The response from the GetLensReview service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for GetLensReview Operation public virtual GetLensReviewResponse GetLensReview(GetLensReviewRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetLensReviewRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLensReviewResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetLensReview operation on AmazonWellArchitectedClient. /// 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 EndGetLensReview /// operation. /// REST API Reference for GetLensReview Operation public virtual IAsyncResult BeginGetLensReview(GetLensReviewRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetLensReviewRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLensReviewResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetLensReview. /// /// Returns a GetLensReviewResult from WellArchitected. /// REST API Reference for GetLensReview Operation public virtual GetLensReviewResponse EndGetLensReview(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetLensReviewReport ///

/// Get lens review report. ///

/// Container for the necessary parameters to execute the GetLensReviewReport service method. /// /// The response from the GetLensReviewReport service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for GetLensReviewReport Operation public virtual GetLensReviewReportResponse GetLensReviewReport(GetLensReviewReportRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetLensReviewReportRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLensReviewReportResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetLensReviewReport operation on AmazonWellArchitectedClient. /// 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 EndGetLensReviewReport /// operation. /// REST API Reference for GetLensReviewReport Operation public virtual IAsyncResult BeginGetLensReviewReport(GetLensReviewReportRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetLensReviewReportRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLensReviewReportResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetLensReviewReport. /// /// Returns a GetLensReviewReportResult from WellArchitected. /// REST API Reference for GetLensReviewReport Operation public virtual GetLensReviewReportResponse EndGetLensReviewReport(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetLensVersionDifference ///

/// Get lens version differences. ///

/// Container for the necessary parameters to execute the GetLensVersionDifference service method. /// /// The response from the GetLensVersionDifference service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for GetLensVersionDifference Operation public virtual GetLensVersionDifferenceResponse GetLensVersionDifference(GetLensVersionDifferenceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetLensVersionDifferenceRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLensVersionDifferenceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetLensVersionDifference operation on AmazonWellArchitectedClient. /// 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 EndGetLensVersionDifference /// operation. /// REST API Reference for GetLensVersionDifference Operation public virtual IAsyncResult BeginGetLensVersionDifference(GetLensVersionDifferenceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetLensVersionDifferenceRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLensVersionDifferenceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetLensVersionDifference. /// /// Returns a GetLensVersionDifferenceResult from WellArchitected. /// REST API Reference for GetLensVersionDifference Operation public virtual GetLensVersionDifferenceResponse EndGetLensVersionDifference(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetMilestone ///

/// Get a milestone for an existing workload. ///

/// Container for the necessary parameters to execute the GetMilestone service method. /// /// The response from the GetMilestone service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for GetMilestone Operation public virtual GetMilestoneResponse GetMilestone(GetMilestoneRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetMilestoneRequestMarshaller.Instance; options.ResponseUnmarshaller = GetMilestoneResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetMilestone operation on AmazonWellArchitectedClient. /// 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 EndGetMilestone /// operation. /// REST API Reference for GetMilestone Operation public virtual IAsyncResult BeginGetMilestone(GetMilestoneRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetMilestoneRequestMarshaller.Instance; options.ResponseUnmarshaller = GetMilestoneResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetMilestone. /// /// Returns a GetMilestoneResult from WellArchitected. /// REST API Reference for GetMilestone Operation public virtual GetMilestoneResponse EndGetMilestone(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetProfile ///

/// Get profile information. ///

/// Container for the necessary parameters to execute the GetProfile service method. /// /// The response from the GetProfile service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for GetProfile Operation public virtual GetProfileResponse GetProfile(GetProfileRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = GetProfileResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetProfile operation on AmazonWellArchitectedClient. /// 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 EndGetProfile /// operation. /// REST API Reference for GetProfile Operation public virtual IAsyncResult BeginGetProfile(GetProfileRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = GetProfileResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetProfile. /// /// Returns a GetProfileResult from WellArchitected. /// REST API Reference for GetProfile Operation public virtual GetProfileResponse EndGetProfile(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetProfileTemplate ///

/// Get profile template. ///

/// Container for the necessary parameters to execute the GetProfileTemplate service method. /// /// The response from the GetProfileTemplate service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for GetProfileTemplate Operation public virtual GetProfileTemplateResponse GetProfileTemplate(GetProfileTemplateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetProfileTemplateRequestMarshaller.Instance; options.ResponseUnmarshaller = GetProfileTemplateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetProfileTemplate operation on AmazonWellArchitectedClient. /// 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 EndGetProfileTemplate /// operation. /// REST API Reference for GetProfileTemplate Operation public virtual IAsyncResult BeginGetProfileTemplate(GetProfileTemplateRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetProfileTemplateRequestMarshaller.Instance; options.ResponseUnmarshaller = GetProfileTemplateResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetProfileTemplate. /// /// Returns a GetProfileTemplateResult from WellArchitected. /// REST API Reference for GetProfileTemplate Operation public virtual GetProfileTemplateResponse EndGetProfileTemplate(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetWorkload ///

/// Get an existing workload. ///

/// Container for the necessary parameters to execute the GetWorkload service method. /// /// The response from the GetWorkload service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for GetWorkload Operation public virtual GetWorkloadResponse GetWorkload(GetWorkloadRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetWorkloadRequestMarshaller.Instance; options.ResponseUnmarshaller = GetWorkloadResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the GetWorkload operation on AmazonWellArchitectedClient. /// 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 EndGetWorkload /// operation. /// REST API Reference for GetWorkload Operation public virtual IAsyncResult BeginGetWorkload(GetWorkloadRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetWorkloadRequestMarshaller.Instance; options.ResponseUnmarshaller = GetWorkloadResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginGetWorkload. /// /// Returns a GetWorkloadResult from WellArchitected. /// REST API Reference for GetWorkload Operation public virtual GetWorkloadResponse EndGetWorkload(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ImportLens ///

/// Import a new custom lens or update an existing custom lens. /// /// /// /// To update an existing custom lens, specify its ARN as the LensAlias. /// If no ARN is specified, a new custom lens is created. /// /// /// /// The new or updated lens will have a status of DRAFT. The lens cannot /// be applied to workloads or shared with other Amazon Web Services accounts until it's /// published with CreateLensVersion. /// /// /// /// Lenses are defined in JSON. For more information, see JSON /// format specification in the Well-Architected Tool User Guide. /// /// /// /// A custom lens cannot exceed 500 KB in size. /// /// /// /// Disclaimer /// /// /// /// Do not include or gather personal identifiable information (PII) of end users or other /// identifiable individuals in or via your custom lenses. If your custom lens or those /// shared with you and used in your account do include or collect PII you are responsible /// for: ensuring that the included PII is processed in accordance with applicable law, /// providing adequate privacy notices, and obtaining necessary consents for processing /// such data. /// /// ///

/// Container for the necessary parameters to execute the ImportLens service method. /// /// The response from the ImportLens service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// The user has reached their resource quota. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for ImportLens Operation public virtual ImportLensResponse ImportLens(ImportLensRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ImportLensRequestMarshaller.Instance; options.ResponseUnmarshaller = ImportLensResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ImportLens operation on AmazonWellArchitectedClient. /// 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 EndImportLens /// operation. /// REST API Reference for ImportLens Operation public virtual IAsyncResult BeginImportLens(ImportLensRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ImportLensRequestMarshaller.Instance; options.ResponseUnmarshaller = ImportLensResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginImportLens. /// /// Returns a ImportLensResult from WellArchitected. /// REST API Reference for ImportLens Operation public virtual ImportLensResponse EndImportLens(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListAnswers ///

/// List of answers for a particular workload and lens. ///

/// Container for the necessary parameters to execute the ListAnswers service method. /// /// The response from the ListAnswers service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for ListAnswers Operation public virtual ListAnswersResponse ListAnswers(ListAnswersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListAnswersRequestMarshaller.Instance; options.ResponseUnmarshaller = ListAnswersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListAnswers operation on AmazonWellArchitectedClient. /// 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 EndListAnswers /// operation. /// REST API Reference for ListAnswers Operation public virtual IAsyncResult BeginListAnswers(ListAnswersRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListAnswersRequestMarshaller.Instance; options.ResponseUnmarshaller = ListAnswersResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListAnswers. /// /// Returns a ListAnswersResult from WellArchitected. /// REST API Reference for ListAnswers Operation public virtual ListAnswersResponse EndListAnswers(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListCheckDetails ///

/// List of Trusted Advisor check details by account related to the workload. ///

/// Container for the necessary parameters to execute the ListCheckDetails service method. /// /// The response from the ListCheckDetails service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for ListCheckDetails Operation public virtual ListCheckDetailsResponse ListCheckDetails(ListCheckDetailsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListCheckDetailsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListCheckDetailsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListCheckDetails operation on AmazonWellArchitectedClient. /// 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 EndListCheckDetails /// operation. /// REST API Reference for ListCheckDetails Operation public virtual IAsyncResult BeginListCheckDetails(ListCheckDetailsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListCheckDetailsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListCheckDetailsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListCheckDetails. /// /// Returns a ListCheckDetailsResult from WellArchitected. /// REST API Reference for ListCheckDetails Operation public virtual ListCheckDetailsResponse EndListCheckDetails(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListCheckSummaries ///

/// List of Trusted Advisor checks summarized for all accounts related to the workload. ///

/// Container for the necessary parameters to execute the ListCheckSummaries service method. /// /// The response from the ListCheckSummaries service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for ListCheckSummaries Operation public virtual ListCheckSummariesResponse ListCheckSummaries(ListCheckSummariesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListCheckSummariesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListCheckSummariesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListCheckSummaries operation on AmazonWellArchitectedClient. /// 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 EndListCheckSummaries /// operation. /// REST API Reference for ListCheckSummaries Operation public virtual IAsyncResult BeginListCheckSummaries(ListCheckSummariesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListCheckSummariesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListCheckSummariesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListCheckSummaries. /// /// Returns a ListCheckSummariesResult from WellArchitected. /// REST API Reference for ListCheckSummaries Operation public virtual ListCheckSummariesResponse EndListCheckSummaries(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListLenses ///

/// List the available lenses. ///

/// Container for the necessary parameters to execute the ListLenses service method. /// /// The response from the ListLenses service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for ListLenses Operation public virtual ListLensesResponse ListLenses(ListLensesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListLensesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLensesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListLenses operation on AmazonWellArchitectedClient. /// 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 EndListLenses /// operation. /// REST API Reference for ListLenses Operation public virtual IAsyncResult BeginListLenses(ListLensesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListLensesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLensesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListLenses. /// /// Returns a ListLensesResult from WellArchitected. /// REST API Reference for ListLenses Operation public virtual ListLensesResponse EndListLenses(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListLensReviewImprovements ///

/// List lens review improvements. ///

/// Container for the necessary parameters to execute the ListLensReviewImprovements service method. /// /// The response from the ListLensReviewImprovements service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for ListLensReviewImprovements Operation public virtual ListLensReviewImprovementsResponse ListLensReviewImprovements(ListLensReviewImprovementsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListLensReviewImprovementsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLensReviewImprovementsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListLensReviewImprovements operation on AmazonWellArchitectedClient. /// 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 EndListLensReviewImprovements /// operation. /// REST API Reference for ListLensReviewImprovements Operation public virtual IAsyncResult BeginListLensReviewImprovements(ListLensReviewImprovementsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListLensReviewImprovementsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLensReviewImprovementsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListLensReviewImprovements. /// /// Returns a ListLensReviewImprovementsResult from WellArchitected. /// REST API Reference for ListLensReviewImprovements Operation public virtual ListLensReviewImprovementsResponse EndListLensReviewImprovements(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListLensReviews ///

/// List lens reviews for a particular workload. ///

/// Container for the necessary parameters to execute the ListLensReviews service method. /// /// The response from the ListLensReviews service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for ListLensReviews Operation public virtual ListLensReviewsResponse ListLensReviews(ListLensReviewsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListLensReviewsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLensReviewsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListLensReviews operation on AmazonWellArchitectedClient. /// 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 EndListLensReviews /// operation. /// REST API Reference for ListLensReviews Operation public virtual IAsyncResult BeginListLensReviews(ListLensReviewsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListLensReviewsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLensReviewsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListLensReviews. /// /// Returns a ListLensReviewsResult from WellArchitected. /// REST API Reference for ListLensReviews Operation public virtual ListLensReviewsResponse EndListLensReviews(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListLensShares ///

/// List the lens shares associated with the lens. ///

/// Container for the necessary parameters to execute the ListLensShares service method. /// /// The response from the ListLensShares service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for ListLensShares Operation public virtual ListLensSharesResponse ListLensShares(ListLensSharesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListLensSharesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLensSharesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListLensShares operation on AmazonWellArchitectedClient. /// 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 EndListLensShares /// operation. /// REST API Reference for ListLensShares Operation public virtual IAsyncResult BeginListLensShares(ListLensSharesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListLensSharesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLensSharesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListLensShares. /// /// Returns a ListLensSharesResult from WellArchitected. /// REST API Reference for ListLensShares Operation public virtual ListLensSharesResponse EndListLensShares(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListMilestones ///

/// List all milestones for an existing workload. ///

/// Container for the necessary parameters to execute the ListMilestones service method. /// /// The response from the ListMilestones service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for ListMilestones Operation public virtual ListMilestonesResponse ListMilestones(ListMilestonesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListMilestonesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListMilestonesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListMilestones operation on AmazonWellArchitectedClient. /// 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 EndListMilestones /// operation. /// REST API Reference for ListMilestones Operation public virtual IAsyncResult BeginListMilestones(ListMilestonesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListMilestonesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListMilestonesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListMilestones. /// /// Returns a ListMilestonesResult from WellArchitected. /// REST API Reference for ListMilestones Operation public virtual ListMilestonesResponse EndListMilestones(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListNotifications ///

/// List lens notifications. ///

/// Container for the necessary parameters to execute the ListNotifications service method. /// /// The response from the ListNotifications service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for ListNotifications Operation public virtual ListNotificationsResponse ListNotifications(ListNotificationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListNotificationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListNotificationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListNotifications operation on AmazonWellArchitectedClient. /// 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 EndListNotifications /// operation. /// REST API Reference for ListNotifications Operation public virtual IAsyncResult BeginListNotifications(ListNotificationsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListNotificationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListNotificationsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListNotifications. /// /// Returns a ListNotificationsResult from WellArchitected. /// REST API Reference for ListNotifications Operation public virtual ListNotificationsResponse EndListNotifications(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListProfileNotifications ///

/// List profile notifications. ///

/// Container for the necessary parameters to execute the ListProfileNotifications service method. /// /// The response from the ListProfileNotifications service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for ListProfileNotifications Operation public virtual ListProfileNotificationsResponse ListProfileNotifications(ListProfileNotificationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListProfileNotificationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListProfileNotificationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListProfileNotifications operation on AmazonWellArchitectedClient. /// 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 EndListProfileNotifications /// operation. /// REST API Reference for ListProfileNotifications Operation public virtual IAsyncResult BeginListProfileNotifications(ListProfileNotificationsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListProfileNotificationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListProfileNotificationsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListProfileNotifications. /// /// Returns a ListProfileNotificationsResult from WellArchitected. /// REST API Reference for ListProfileNotifications Operation public virtual ListProfileNotificationsResponse EndListProfileNotifications(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListProfiles ///

/// List profiles. ///

/// Container for the necessary parameters to execute the ListProfiles service method. /// /// The response from the ListProfiles service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for ListProfiles Operation public virtual ListProfilesResponse ListProfiles(ListProfilesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListProfilesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListProfilesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListProfiles operation on AmazonWellArchitectedClient. /// 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 EndListProfiles /// operation. /// REST API Reference for ListProfiles Operation public virtual IAsyncResult BeginListProfiles(ListProfilesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListProfilesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListProfilesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListProfiles. /// /// Returns a ListProfilesResult from WellArchitected. /// REST API Reference for ListProfiles Operation public virtual ListProfilesResponse EndListProfiles(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListProfileShares ///

/// List profile shares. ///

/// Container for the necessary parameters to execute the ListProfileShares service method. /// /// The response from the ListProfileShares service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for ListProfileShares Operation public virtual ListProfileSharesResponse ListProfileShares(ListProfileSharesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListProfileSharesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListProfileSharesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListProfileShares operation on AmazonWellArchitectedClient. /// 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 EndListProfileShares /// operation. /// REST API Reference for ListProfileShares Operation public virtual IAsyncResult BeginListProfileShares(ListProfileSharesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListProfileSharesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListProfileSharesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListProfileShares. /// /// Returns a ListProfileSharesResult from WellArchitected. /// REST API Reference for ListProfileShares Operation public virtual ListProfileSharesResponse EndListProfileShares(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListShareInvitations ///

/// List the workload invitations. ///

/// Container for the necessary parameters to execute the ListShareInvitations service method. /// /// The response from the ListShareInvitations service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for ListShareInvitations Operation public virtual ListShareInvitationsResponse ListShareInvitations(ListShareInvitationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListShareInvitationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListShareInvitationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListShareInvitations operation on AmazonWellArchitectedClient. /// 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 EndListShareInvitations /// operation. /// REST API Reference for ListShareInvitations Operation public virtual IAsyncResult BeginListShareInvitations(ListShareInvitationsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListShareInvitationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListShareInvitationsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListShareInvitations. /// /// Returns a ListShareInvitationsResult from WellArchitected. /// REST API Reference for ListShareInvitations Operation public virtual ListShareInvitationsResponse EndListShareInvitations(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListTagsForResource ///

/// List the tags for a resource. /// /// /// /// The WorkloadArn parameter can be a workload ARN, a custom lens ARN, or a profile ARN. /// /// ///

/// Container for the necessary parameters to execute the ListTagsForResource service method. /// /// The response from the ListTagsForResource service method, as returned by WellArchitected. /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// 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 AmazonWellArchitectedClient. /// 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 WellArchitected. /// REST API Reference for ListTagsForResource Operation public virtual ListTagsForResourceResponse EndListTagsForResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListWorkloads ///

/// Paginated list of workloads. ///

/// Container for the necessary parameters to execute the ListWorkloads service method. /// /// The response from the ListWorkloads service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for ListWorkloads Operation public virtual ListWorkloadsResponse ListWorkloads(ListWorkloadsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListWorkloadsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListWorkloadsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListWorkloads operation on AmazonWellArchitectedClient. /// 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 EndListWorkloads /// operation. /// REST API Reference for ListWorkloads Operation public virtual IAsyncResult BeginListWorkloads(ListWorkloadsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListWorkloadsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListWorkloadsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListWorkloads. /// /// Returns a ListWorkloadsResult from WellArchitected. /// REST API Reference for ListWorkloads Operation public virtual ListWorkloadsResponse EndListWorkloads(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListWorkloadShares ///

/// List the workload shares associated with the workload. ///

/// Container for the necessary parameters to execute the ListWorkloadShares service method. /// /// The response from the ListWorkloadShares service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for ListWorkloadShares Operation public virtual ListWorkloadSharesResponse ListWorkloadShares(ListWorkloadSharesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListWorkloadSharesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListWorkloadSharesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the ListWorkloadShares operation on AmazonWellArchitectedClient. /// 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 EndListWorkloadShares /// operation. /// REST API Reference for ListWorkloadShares Operation public virtual IAsyncResult BeginListWorkloadShares(ListWorkloadSharesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListWorkloadSharesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListWorkloadSharesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginListWorkloadShares. /// /// Returns a ListWorkloadSharesResult from WellArchitected. /// REST API Reference for ListWorkloadShares Operation public virtual ListWorkloadSharesResponse EndListWorkloadShares(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region TagResource ///

/// Adds one or more tags to the specified resource. /// /// /// /// The WorkloadArn parameter can be a workload ARN, a custom lens ARN, or a profile ARN. /// /// ///

/// Container for the necessary parameters to execute the TagResource service method. /// /// The response from the TagResource service method, as returned by WellArchitected. /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// 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 AmazonWellArchitectedClient. /// 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 WellArchitected. /// REST API Reference for TagResource Operation public virtual TagResourceResponse EndTagResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UntagResource ///

/// Deletes specified tags from a resource. /// /// /// /// The WorkloadArn parameter can be a workload ARN, a custom lens ARN, or a profile ARN. /// /// /// /// To specify multiple tags, use separate tagKeys parameters, for example: /// /// /// /// DELETE /tags/WorkloadArn?tagKeys=key1&tagKeys=key2 /// ///

/// Container for the necessary parameters to execute the UntagResource service method. /// /// The response from the UntagResource service method, as returned by WellArchitected. /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// 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 AmazonWellArchitectedClient. /// 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 WellArchitected. /// REST API Reference for UntagResource Operation public virtual UntagResourceResponse EndUntagResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateAnswer ///

/// Update the answer to a specific question in a workload review. ///

/// Container for the necessary parameters to execute the UpdateAnswer service method. /// /// The response from the UpdateAnswer service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for UpdateAnswer Operation public virtual UpdateAnswerResponse UpdateAnswer(UpdateAnswerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateAnswerRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateAnswerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the UpdateAnswer operation on AmazonWellArchitectedClient. /// 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 EndUpdateAnswer /// operation. /// REST API Reference for UpdateAnswer Operation public virtual IAsyncResult BeginUpdateAnswer(UpdateAnswerRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateAnswerRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateAnswerResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginUpdateAnswer. /// /// Returns a UpdateAnswerResult from WellArchitected. /// REST API Reference for UpdateAnswer Operation public virtual UpdateAnswerResponse EndUpdateAnswer(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateGlobalSettings ///

/// Updates whether the Amazon Web Services account is opted into organization sharing /// and discovery integration features. ///

/// Container for the necessary parameters to execute the UpdateGlobalSettings service method. /// /// The response from the UpdateGlobalSettings service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for UpdateGlobalSettings Operation public virtual UpdateGlobalSettingsResponse UpdateGlobalSettings(UpdateGlobalSettingsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateGlobalSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateGlobalSettingsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the UpdateGlobalSettings operation on AmazonWellArchitectedClient. /// 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 EndUpdateGlobalSettings /// operation. /// REST API Reference for UpdateGlobalSettings Operation public virtual IAsyncResult BeginUpdateGlobalSettings(UpdateGlobalSettingsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateGlobalSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateGlobalSettingsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginUpdateGlobalSettings. /// /// Returns a UpdateGlobalSettingsResult from WellArchitected. /// REST API Reference for UpdateGlobalSettings Operation public virtual UpdateGlobalSettingsResponse EndUpdateGlobalSettings(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateLensReview ///

/// Update lens review for a particular workload. ///

/// Container for the necessary parameters to execute the UpdateLensReview service method. /// /// The response from the UpdateLensReview service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for UpdateLensReview Operation public virtual UpdateLensReviewResponse UpdateLensReview(UpdateLensReviewRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateLensReviewRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateLensReviewResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the UpdateLensReview operation on AmazonWellArchitectedClient. /// 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 EndUpdateLensReview /// operation. /// REST API Reference for UpdateLensReview Operation public virtual IAsyncResult BeginUpdateLensReview(UpdateLensReviewRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateLensReviewRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateLensReviewResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginUpdateLensReview. /// /// Returns a UpdateLensReviewResult from WellArchitected. /// REST API Reference for UpdateLensReview Operation public virtual UpdateLensReviewResponse EndUpdateLensReview(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateProfile ///

/// Update a profile. ///

/// Container for the necessary parameters to execute the UpdateProfile service method. /// /// The response from the UpdateProfile service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for UpdateProfile Operation public virtual UpdateProfileResponse UpdateProfile(UpdateProfileRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateProfileResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the UpdateProfile operation on AmazonWellArchitectedClient. /// 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 EndUpdateProfile /// operation. /// REST API Reference for UpdateProfile Operation public virtual IAsyncResult BeginUpdateProfile(UpdateProfileRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateProfileResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginUpdateProfile. /// /// Returns a UpdateProfileResult from WellArchitected. /// REST API Reference for UpdateProfile Operation public virtual UpdateProfileResponse EndUpdateProfile(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateShareInvitation ///

/// Update a workload or custom lens share invitation. /// /// /// /// This API operation can be called independently of any resource. Previous documentation /// implied that a workload ARN must be specified. /// /// ///

/// Container for the necessary parameters to execute the UpdateShareInvitation service method. /// /// The response from the UpdateShareInvitation service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for UpdateShareInvitation Operation public virtual UpdateShareInvitationResponse UpdateShareInvitation(UpdateShareInvitationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateShareInvitationRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateShareInvitationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the UpdateShareInvitation operation on AmazonWellArchitectedClient. /// 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 EndUpdateShareInvitation /// operation. /// REST API Reference for UpdateShareInvitation Operation public virtual IAsyncResult BeginUpdateShareInvitation(UpdateShareInvitationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateShareInvitationRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateShareInvitationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginUpdateShareInvitation. /// /// Returns a UpdateShareInvitationResult from WellArchitected. /// REST API Reference for UpdateShareInvitation Operation public virtual UpdateShareInvitationResponse EndUpdateShareInvitation(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateWorkload ///

/// Update an existing workload. ///

/// Container for the necessary parameters to execute the UpdateWorkload service method. /// /// The response from the UpdateWorkload service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for UpdateWorkload Operation public virtual UpdateWorkloadResponse UpdateWorkload(UpdateWorkloadRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateWorkloadRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateWorkloadResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the UpdateWorkload operation on AmazonWellArchitectedClient. /// 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 EndUpdateWorkload /// operation. /// REST API Reference for UpdateWorkload Operation public virtual IAsyncResult BeginUpdateWorkload(UpdateWorkloadRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateWorkloadRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateWorkloadResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginUpdateWorkload. /// /// Returns a UpdateWorkloadResult from WellArchitected. /// REST API Reference for UpdateWorkload Operation public virtual UpdateWorkloadResponse EndUpdateWorkload(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateWorkloadShare ///

/// Update a workload share. ///

/// Container for the necessary parameters to execute the UpdateWorkloadShare service method. /// /// The response from the UpdateWorkloadShare service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for UpdateWorkloadShare Operation public virtual UpdateWorkloadShareResponse UpdateWorkloadShare(UpdateWorkloadShareRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateWorkloadShareRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateWorkloadShareResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the UpdateWorkloadShare operation on AmazonWellArchitectedClient. /// 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 EndUpdateWorkloadShare /// operation. /// REST API Reference for UpdateWorkloadShare Operation public virtual IAsyncResult BeginUpdateWorkloadShare(UpdateWorkloadShareRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateWorkloadShareRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateWorkloadShareResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginUpdateWorkloadShare. /// /// Returns a UpdateWorkloadShareResult from WellArchitected. /// REST API Reference for UpdateWorkloadShare Operation public virtual UpdateWorkloadShareResponse EndUpdateWorkloadShare(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpgradeLensReview ///

/// Upgrade lens review for a particular workload. ///

/// Container for the necessary parameters to execute the UpgradeLensReview service method. /// /// The response from the UpgradeLensReview service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for UpgradeLensReview Operation public virtual UpgradeLensReviewResponse UpgradeLensReview(UpgradeLensReviewRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpgradeLensReviewRequestMarshaller.Instance; options.ResponseUnmarshaller = UpgradeLensReviewResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the UpgradeLensReview operation on AmazonWellArchitectedClient. /// 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 EndUpgradeLensReview /// operation. /// REST API Reference for UpgradeLensReview Operation public virtual IAsyncResult BeginUpgradeLensReview(UpgradeLensReviewRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpgradeLensReviewRequestMarshaller.Instance; options.ResponseUnmarshaller = UpgradeLensReviewResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginUpgradeLensReview. /// /// Returns a UpgradeLensReviewResult from WellArchitected. /// REST API Reference for UpgradeLensReview Operation public virtual UpgradeLensReviewResponse EndUpgradeLensReview(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpgradeProfileVersion ///

/// Upgrade a profile. ///

/// Container for the necessary parameters to execute the UpgradeProfileVersion service method. /// /// The response from the UpgradeProfileVersion service method, as returned by WellArchitected. /// /// User does not have sufficient access to perform this action. /// /// /// The resource has already been processed, was deleted, or is too large. /// /// /// There is a problem with the Well-Architected Tool API service. /// /// /// The requested resource was not found. /// /// /// Request was denied due to request throttling. /// /// /// The user input is not valid. /// /// REST API Reference for UpgradeProfileVersion Operation public virtual UpgradeProfileVersionResponse UpgradeProfileVersion(UpgradeProfileVersionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpgradeProfileVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = UpgradeProfileVersionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// Container for the necessary parameters to execute the UpgradeProfileVersion operation on AmazonWellArchitectedClient. /// 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 EndUpgradeProfileVersion /// operation. /// REST API Reference for UpgradeProfileVersion Operation public virtual IAsyncResult BeginUpgradeProfileVersion(UpgradeProfileVersionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpgradeProfileVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = UpgradeProfileVersionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

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

/// /// The IAsyncResult returned by the call to BeginUpgradeProfileVersion. /// /// Returns a UpgradeProfileVersionResult from WellArchitected. /// REST API Reference for UpgradeProfileVersion Operation public virtual UpgradeProfileVersionResponse EndUpgradeProfileVersion(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion } }