/*
 * 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 workspaces-2015-04-08.normal.json service model.
 */
using System;
using System.Collections.Generic;
using System.Net;
using Amazon.WorkSpaces.Model;
using Amazon.WorkSpaces.Model.Internal.MarshallTransformations;
using Amazon.WorkSpaces.Internal;
using Amazon.Runtime;
using Amazon.Runtime.Internal;
using Amazon.Runtime.Internal.Auth;
using Amazon.Runtime.Internal.Transform;
namespace Amazon.WorkSpaces
{
    /// 
    /// Implementation for accessing WorkSpaces
    ///
    /// Amazon WorkSpaces Service 
    /// 
    /// Amazon WorkSpaces enables you to provision virtual, cloud-based Microsoft Windows
    /// or Amazon Linux desktops for your users, known as WorkSpaces. WorkSpaces eliminates
    /// the need to procure and deploy hardware or install complex software. You can quickly
    /// add or remove users as your needs change. Users can access their virtual desktops
    /// from multiple devices or web browsers.
    /// 
    ///  
    /// 
    /// This API Reference provides detailed information about the actions, data types, parameters,
    /// and errors of the WorkSpaces service. For more information about the supported Amazon
    /// Web Services Regions, endpoints, and service quotas of the Amazon WorkSpaces service,
    /// see WorkSpaces endpoints
    /// and quotas in the Amazon Web Services General Reference.
    /// 
    ///  
    /// 
    /// You can also manage your WorkSpaces resources using the WorkSpaces console, Command
    /// Line Interface (CLI), and SDKs. For more information about administering WorkSpaces,
    /// see the Amazon
    /// WorkSpaces Administration Guide. For more information about using the Amazon WorkSpaces
    /// client application or web browser to access provisioned WorkSpaces, see the Amazon
    /// WorkSpaces User Guide. For more information about using the CLI to manage your
    /// WorkSpaces resources, see the WorkSpaces
    /// section of the CLI Reference.
    /// 
    /// 
    public partial class AmazonWorkSpacesClient : AmazonServiceClient, IAmazonWorkSpaces
    {
        private static IServiceMetadata serviceMetadata = new AmazonWorkSpacesMetadata();
#if BCL45 || AWS_ASYNC_ENUMERABLES_API
        private IWorkSpacesPaginatorFactory _paginators;
        /// 
        /// Paginators for the service
        /// 
        public IWorkSpacesPaginatorFactory Paginators 
        {
            get 
            {
                if (this._paginators == null) 
                {
                    this._paginators = new WorkSpacesPaginatorFactory(this);
                }
                return this._paginators;
            }
        }
#endif
        #region Constructors
        /// 
        /// Constructs AmazonWorkSpacesClient 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 AmazonWorkSpacesClient()
            : base(FallbackCredentialsFactory.GetCredentials(), new AmazonWorkSpacesConfig()) { }
        /// 
        /// Constructs AmazonWorkSpacesClient with the credentials loaded from the application's
        /// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance.
        /// 
        /// Example App.config with credentials set. 
        /// 
        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        /// 
        ///
        /// 
        /// The region to connect.
        public AmazonWorkSpacesClient(RegionEndpoint region)
            : base(FallbackCredentialsFactory.GetCredentials(), new AmazonWorkSpacesConfig{RegionEndpoint = region}) { }
        /// 
        /// Constructs AmazonWorkSpacesClient with the credentials loaded from the application's
        /// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance.
        /// 
        /// Example App.config with credentials set. 
        /// 
        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        /// 
        ///
        /// 
        /// The AmazonWorkSpacesClient Configuration Object
        public AmazonWorkSpacesClient(AmazonWorkSpacesConfig config)
            : base(FallbackCredentialsFactory.GetCredentials(config), config){}
        /// 
        /// Constructs AmazonWorkSpacesClient with AWS Credentials
        /// 
        /// AWS Credentials
        public AmazonWorkSpacesClient(AWSCredentials credentials)
            : this(credentials, new AmazonWorkSpacesConfig())
        {
        }
        /// 
        /// Constructs AmazonWorkSpacesClient with AWS Credentials
        /// 
        /// AWS Credentials
        /// The region to connect.
        public AmazonWorkSpacesClient(AWSCredentials credentials, RegionEndpoint region)
            : this(credentials, new AmazonWorkSpacesConfig{RegionEndpoint = region})
        {
        }
        /// 
        /// Constructs AmazonWorkSpacesClient with AWS Credentials and an
        /// AmazonWorkSpacesClient Configuration object.
        /// 
        /// AWS Credentials
        /// The AmazonWorkSpacesClient Configuration Object
        public AmazonWorkSpacesClient(AWSCredentials credentials, AmazonWorkSpacesConfig clientConfig)
            : base(credentials, clientConfig)
        {
        }
        /// 
        /// Constructs AmazonWorkSpacesClient with AWS Access Key ID and AWS Secret Key
        /// 
        /// AWS Access Key ID
        /// AWS Secret Access Key
        public AmazonWorkSpacesClient(string awsAccessKeyId, string awsSecretAccessKey)
            : this(awsAccessKeyId, awsSecretAccessKey, new AmazonWorkSpacesConfig())
        {
        }
        /// 
        /// Constructs AmazonWorkSpacesClient with AWS Access Key ID and AWS Secret Key
        /// 
        /// AWS Access Key ID
        /// AWS Secret Access Key
        /// The region to connect.
        public AmazonWorkSpacesClient(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region)
            : this(awsAccessKeyId, awsSecretAccessKey, new AmazonWorkSpacesConfig() {RegionEndpoint=region})
        {
        }
        /// 
        /// Constructs AmazonWorkSpacesClient with AWS Access Key ID, AWS Secret Key and an
        /// AmazonWorkSpacesClient Configuration object. 
        /// 
        /// AWS Access Key ID
        /// AWS Secret Access Key
        /// The AmazonWorkSpacesClient Configuration Object
        public AmazonWorkSpacesClient(string awsAccessKeyId, string awsSecretAccessKey, AmazonWorkSpacesConfig clientConfig)
            : base(awsAccessKeyId, awsSecretAccessKey, clientConfig)
        {
        }
        /// 
        /// Constructs AmazonWorkSpacesClient with AWS Access Key ID and AWS Secret Key
        /// 
        /// AWS Access Key ID
        /// AWS Secret Access Key
        /// AWS Session Token
        public AmazonWorkSpacesClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken)
            : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonWorkSpacesConfig())
        {
        }
        /// 
        /// Constructs AmazonWorkSpacesClient 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 AmazonWorkSpacesClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region)
            : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonWorkSpacesConfig{RegionEndpoint = region})
        {
        }
        /// 
        /// Constructs AmazonWorkSpacesClient with AWS Access Key ID, AWS Secret Key and an
        /// AmazonWorkSpacesClient Configuration object. 
        /// 
        /// AWS Access Key ID
        /// AWS Secret Access Key
        /// AWS Session Token
        /// The AmazonWorkSpacesClient Configuration Object
        public AmazonWorkSpacesClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonWorkSpacesConfig 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 AmazonWorkSpacesEndpointResolver());
        }
        /// 
        /// 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  AssociateConnectionAlias
        /// 
        /// Associates the specified connection alias with the specified directory to enable cross-Region
        /// redirection. For more information, see 
        /// Cross-Region Redirection for Amazon WorkSpaces.
        /// 
        ///   
        /// 
        /// Before performing this operation, call 
        /// DescribeConnectionAliases to make sure that the current state of the connection
        /// alias is CREATED.
        /// 
        ///  
        /// 
        /// Container for the necessary parameters to execute the AssociateConnectionAlias service method.
        /// 
        /// The response from the AssociateConnectionAlias service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The state of the resource is not valid for this operation.
        /// 
        /// 
        /// This operation is not supported.
        /// 
        /// 
        /// The resource is associated with a directory.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for AssociateConnectionAlias Operation
        public virtual AssociateConnectionAliasResponse AssociateConnectionAlias(AssociateConnectionAliasRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateConnectionAliasRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateConnectionAliasResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the AssociateConnectionAlias operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the AssociateConnectionAlias operation on AmazonWorkSpacesClient.
        /// 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 EndAssociateConnectionAlias
        ///         operation.
        /// REST API Reference for AssociateConnectionAlias Operation
        public virtual IAsyncResult BeginAssociateConnectionAlias(AssociateConnectionAliasRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateConnectionAliasRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateConnectionAliasResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  AssociateConnectionAlias operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginAssociateConnectionAlias.
        /// 
        /// Returns a  AssociateConnectionAliasResult from WorkSpaces.
        /// REST API Reference for AssociateConnectionAlias Operation
        public virtual AssociateConnectionAliasResponse EndAssociateConnectionAlias(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  AssociateIpGroups
        /// 
        /// Associates the specified IP access control group with the specified directory.
        /// 
        /// Container for the necessary parameters to execute the AssociateIpGroups service method.
        /// 
        /// The response from the AssociateIpGroups service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The state of the resource is not valid for this operation.
        /// 
        /// 
        /// This operation is not supported.
        /// 
        /// 
        /// Your resource limits have been exceeded.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for AssociateIpGroups Operation
        public virtual AssociateIpGroupsResponse AssociateIpGroups(AssociateIpGroupsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateIpGroupsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateIpGroupsResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the AssociateIpGroups operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the AssociateIpGroups operation on AmazonWorkSpacesClient.
        /// 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 EndAssociateIpGroups
        ///         operation.
        /// REST API Reference for AssociateIpGroups Operation
        public virtual IAsyncResult BeginAssociateIpGroups(AssociateIpGroupsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateIpGroupsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateIpGroupsResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  AssociateIpGroups operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginAssociateIpGroups.
        /// 
        /// Returns a  AssociateIpGroupsResult from WorkSpaces.
        /// REST API Reference for AssociateIpGroups Operation
        public virtual AssociateIpGroupsResponse EndAssociateIpGroups(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  AuthorizeIpRules
        /// 
        /// Adds one or more rules to the specified IP access control group.
        /// 
        ///  
        /// 
        /// This action gives users permission to access their WorkSpaces from the CIDR address
        /// ranges specified in the rules.
        /// 
        /// 
        /// Container for the necessary parameters to execute the AuthorizeIpRules service method.
        /// 
        /// The response from the AuthorizeIpRules service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The state of the resource is not valid for this operation.
        /// 
        /// 
        /// Your resource limits have been exceeded.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for AuthorizeIpRules Operation
        public virtual AuthorizeIpRulesResponse AuthorizeIpRules(AuthorizeIpRulesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AuthorizeIpRulesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AuthorizeIpRulesResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the AuthorizeIpRules operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the AuthorizeIpRules operation on AmazonWorkSpacesClient.
        /// 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 EndAuthorizeIpRules
        ///         operation.
        /// REST API Reference for AuthorizeIpRules Operation
        public virtual IAsyncResult BeginAuthorizeIpRules(AuthorizeIpRulesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AuthorizeIpRulesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AuthorizeIpRulesResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  AuthorizeIpRules operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginAuthorizeIpRules.
        /// 
        /// Returns a  AuthorizeIpRulesResult from WorkSpaces.
        /// REST API Reference for AuthorizeIpRules Operation
        public virtual AuthorizeIpRulesResponse EndAuthorizeIpRules(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  CopyWorkspaceImage
        /// 
        /// Copies the specified image from the specified Region to the current Region. For more
        /// information about copying images, see 
        /// Copy a Custom WorkSpaces Image.
        /// 
        ///  
        /// 
        /// In the China (Ningxia) Region, you can copy images only within the same Region.
        /// 
        ///  
        /// 
        /// In Amazon Web Services GovCloud (US), to copy images to and from other Regions, contact
        /// Amazon Web Services Support.
        /// 
        ///   
        /// 
        /// Before copying a shared image, be sure to verify that it has been shared from the
        /// correct Amazon Web Services account. To determine if an image has been shared and
        /// to see the ID of the Amazon Web Services account that owns an image, use the DescribeWorkSpaceImages
        /// and DescribeWorkspaceImagePermissions
        /// API operations. 
        /// 
        ///  
        /// 
        /// Container for the necessary parameters to execute the CopyWorkspaceImage service method.
        /// 
        /// The response from the CopyWorkspaceImage service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// This operation is not supported.
        /// 
        /// 
        /// The specified resource already exists.
        /// 
        /// 
        /// Your resource limits have been exceeded.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// 
        /// The specified resource is not available.
        /// 
        /// REST API Reference for CopyWorkspaceImage Operation
        public virtual CopyWorkspaceImageResponse CopyWorkspaceImage(CopyWorkspaceImageRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CopyWorkspaceImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CopyWorkspaceImageResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the CopyWorkspaceImage operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the CopyWorkspaceImage operation on AmazonWorkSpacesClient.
        /// 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 EndCopyWorkspaceImage
        ///         operation.
        /// REST API Reference for CopyWorkspaceImage Operation
        public virtual IAsyncResult BeginCopyWorkspaceImage(CopyWorkspaceImageRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CopyWorkspaceImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CopyWorkspaceImageResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  CopyWorkspaceImage operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginCopyWorkspaceImage.
        /// 
        /// Returns a  CopyWorkspaceImageResult from WorkSpaces.
        /// REST API Reference for CopyWorkspaceImage Operation
        public virtual CopyWorkspaceImageResponse EndCopyWorkspaceImage(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  CreateConnectClientAddIn
        /// 
        /// Creates a client-add-in for Amazon Connect within a directory. You can create only
        /// one Amazon Connect client add-in within a directory.
        /// 
        ///  
        /// 
        /// This client add-in allows WorkSpaces users to seamlessly connect to Amazon Connect.
        /// 
        /// 
        /// Container for the necessary parameters to execute the CreateConnectClientAddIn service method.
        /// 
        /// The response from the CreateConnectClientAddIn service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The specified resource already exists.
        /// 
        /// 
        /// The resource could not be created.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for CreateConnectClientAddIn Operation
        public virtual CreateConnectClientAddInResponse CreateConnectClientAddIn(CreateConnectClientAddInRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateConnectClientAddInRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateConnectClientAddInResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the CreateConnectClientAddIn operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the CreateConnectClientAddIn operation on AmazonWorkSpacesClient.
        /// 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 EndCreateConnectClientAddIn
        ///         operation.
        /// REST API Reference for CreateConnectClientAddIn Operation
        public virtual IAsyncResult BeginCreateConnectClientAddIn(CreateConnectClientAddInRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateConnectClientAddInRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateConnectClientAddInResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  CreateConnectClientAddIn operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginCreateConnectClientAddIn.
        /// 
        /// Returns a  CreateConnectClientAddInResult from WorkSpaces.
        /// REST API Reference for CreateConnectClientAddIn Operation
        public virtual CreateConnectClientAddInResponse EndCreateConnectClientAddIn(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  CreateConnectionAlias
        /// 
        /// Creates the specified connection alias for use with cross-Region redirection. For
        /// more information, see 
        /// Cross-Region Redirection for Amazon WorkSpaces.
        /// 
        /// Container for the necessary parameters to execute the CreateConnectionAlias service method.
        /// 
        /// The response from the CreateConnectionAlias service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The state of the resource is not valid for this operation.
        /// 
        /// 
        /// This operation is not supported.
        /// 
        /// 
        /// The specified resource already exists.
        /// 
        /// 
        /// Your resource limits have been exceeded.
        /// 
        /// REST API Reference for CreateConnectionAlias Operation
        public virtual CreateConnectionAliasResponse CreateConnectionAlias(CreateConnectionAliasRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateConnectionAliasRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateConnectionAliasResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the CreateConnectionAlias operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the CreateConnectionAlias operation on AmazonWorkSpacesClient.
        /// 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 EndCreateConnectionAlias
        ///         operation.
        /// REST API Reference for CreateConnectionAlias Operation
        public virtual IAsyncResult BeginCreateConnectionAlias(CreateConnectionAliasRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateConnectionAliasRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateConnectionAliasResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  CreateConnectionAlias operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginCreateConnectionAlias.
        /// 
        /// Returns a  CreateConnectionAliasResult from WorkSpaces.
        /// REST API Reference for CreateConnectionAlias Operation
        public virtual CreateConnectionAliasResponse EndCreateConnectionAlias(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  CreateIpGroup
        /// 
        /// Creates an IP access control group.
        /// 
        ///  
        /// 
        /// An IP access control group provides you with the ability to control the IP addresses
        /// from which users are allowed to access their WorkSpaces. To specify the CIDR address
        /// ranges, add rules to your IP access control group and then associate the group with
        /// your directory. You can add rules when you create the group or at any time using AuthorizeIpRules.
        /// 
        ///  
        /// 
        /// There is a default IP access control group associated with your directory. If you
        /// don't associate an IP access control group with your directory, the default group
        /// is used. The default group includes a default rule that allows users to access their
        /// WorkSpaces from anywhere. You cannot modify the default IP access control group for
        /// your directory.
        /// 
        /// 
        /// Container for the necessary parameters to execute the CreateIpGroup service method.
        /// 
        /// The response from the CreateIpGroup service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The specified resource already exists.
        /// 
        /// 
        /// The resource could not be created.
        /// 
        /// 
        /// Your resource limits have been exceeded.
        /// 
        /// REST API Reference for CreateIpGroup Operation
        public virtual CreateIpGroupResponse CreateIpGroup(CreateIpGroupRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateIpGroupRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateIpGroupResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the CreateIpGroup operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the CreateIpGroup operation on AmazonWorkSpacesClient.
        /// 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 EndCreateIpGroup
        ///         operation.
        /// REST API Reference for CreateIpGroup Operation
        public virtual IAsyncResult BeginCreateIpGroup(CreateIpGroupRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateIpGroupRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateIpGroupResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  CreateIpGroup operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginCreateIpGroup.
        /// 
        /// Returns a  CreateIpGroupResult from WorkSpaces.
        /// REST API Reference for CreateIpGroup Operation
        public virtual CreateIpGroupResponse EndCreateIpGroup(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  CreateStandbyWorkspaces
        /// 
        /// Creates a standby WorkSpace in a secondary Region.
        /// 
        /// Container for the necessary parameters to execute the CreateStandbyWorkspaces service method.
        /// 
        /// The response from the CreateStandbyWorkspaces service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// This operation is not supported.
        /// 
        /// 
        /// Your resource limits have been exceeded.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for CreateStandbyWorkspaces Operation
        public virtual CreateStandbyWorkspacesResponse CreateStandbyWorkspaces(CreateStandbyWorkspacesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateStandbyWorkspacesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateStandbyWorkspacesResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the CreateStandbyWorkspaces operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the CreateStandbyWorkspaces operation on AmazonWorkSpacesClient.
        /// 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 EndCreateStandbyWorkspaces
        ///         operation.
        /// REST API Reference for CreateStandbyWorkspaces Operation
        public virtual IAsyncResult BeginCreateStandbyWorkspaces(CreateStandbyWorkspacesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateStandbyWorkspacesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateStandbyWorkspacesResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  CreateStandbyWorkspaces operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginCreateStandbyWorkspaces.
        /// 
        /// Returns a  CreateStandbyWorkspacesResult from WorkSpaces.
        /// REST API Reference for CreateStandbyWorkspaces Operation
        public virtual CreateStandbyWorkspacesResponse EndCreateStandbyWorkspaces(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  CreateTags
        /// 
        /// Creates the specified tags for the specified WorkSpaces resource.
        /// 
        /// Container for the necessary parameters to execute the CreateTags service method.
        /// 
        /// The response from the CreateTags service method, as returned by WorkSpaces.
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// Your resource limits have been exceeded.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for CreateTags Operation
        public virtual CreateTagsResponse CreateTags(CreateTagsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTagsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTagsResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the CreateTags operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the CreateTags operation on AmazonWorkSpacesClient.
        /// 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 EndCreateTags
        ///         operation.
        /// REST API Reference for CreateTags Operation
        public virtual IAsyncResult BeginCreateTags(CreateTagsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTagsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTagsResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  CreateTags operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginCreateTags.
        /// 
        /// Returns a  CreateTagsResult from WorkSpaces.
        /// REST API Reference for CreateTags Operation
        public virtual CreateTagsResponse EndCreateTags(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  CreateUpdatedWorkspaceImage
        /// 
        /// Creates a new updated WorkSpace image based on the specified source image. The new
        /// updated WorkSpace image has the latest drivers and other updates required by the Amazon
        /// WorkSpaces components.
        /// 
        ///  
        /// 
        /// To determine which WorkSpace images need to be updated with the latest Amazon WorkSpaces
        /// requirements, use 
        /// DescribeWorkspaceImages.
        /// 
        ///    -  
        /// 
        /// Only Windows 10, Windows Server 2016, and Windows Server 2019 WorkSpace images can
        /// be programmatically updated at this time.
        /// 
        ///  
-  
        /// 
        /// Microsoft Windows updates and other application updates are not included in the update
        /// process.
        /// 
        ///  
-  
        /// 
        /// The source WorkSpace image is not deleted. You can delete the source image after you've
        /// verified your new updated image and created a new bundle. 
        /// 
        ///  
/// 
        /// Container for the necessary parameters to execute the CreateUpdatedWorkspaceImage service method.
        /// 
        /// The response from the CreateUpdatedWorkspaceImage service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The state of the resource is not valid for this operation.
        /// 
        /// 
        /// This operation is not supported.
        /// 
        /// 
        /// The specified resource already exists.
        /// 
        /// 
        /// Your resource limits have been exceeded.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for CreateUpdatedWorkspaceImage Operation
        public virtual CreateUpdatedWorkspaceImageResponse CreateUpdatedWorkspaceImage(CreateUpdatedWorkspaceImageRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateUpdatedWorkspaceImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateUpdatedWorkspaceImageResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the CreateUpdatedWorkspaceImage operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the CreateUpdatedWorkspaceImage operation on AmazonWorkSpacesClient.
        /// 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 EndCreateUpdatedWorkspaceImage
        ///         operation.
        /// REST API Reference for CreateUpdatedWorkspaceImage Operation
        public virtual IAsyncResult BeginCreateUpdatedWorkspaceImage(CreateUpdatedWorkspaceImageRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateUpdatedWorkspaceImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateUpdatedWorkspaceImageResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  CreateUpdatedWorkspaceImage operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginCreateUpdatedWorkspaceImage.
        /// 
        /// Returns a  CreateUpdatedWorkspaceImageResult from WorkSpaces.
        /// REST API Reference for CreateUpdatedWorkspaceImage Operation
        public virtual CreateUpdatedWorkspaceImageResponse EndCreateUpdatedWorkspaceImage(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  CreateWorkspaceBundle
        /// 
        /// Creates the specified WorkSpace bundle. For more information about creating WorkSpace
        /// bundles, see 
        /// Create a Custom WorkSpaces Image and Bundle.
        /// 
        /// Container for the necessary parameters to execute the CreateWorkspaceBundle service method.
        /// 
        /// The response from the CreateWorkspaceBundle service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The specified resource already exists.
        /// 
        /// 
        /// Your resource limits have been exceeded.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// 
        /// The specified resource is not available.
        /// 
        /// REST API Reference for CreateWorkspaceBundle Operation
        public virtual CreateWorkspaceBundleResponse CreateWorkspaceBundle(CreateWorkspaceBundleRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateWorkspaceBundleRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateWorkspaceBundleResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the CreateWorkspaceBundle operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the CreateWorkspaceBundle operation on AmazonWorkSpacesClient.
        /// 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 EndCreateWorkspaceBundle
        ///         operation.
        /// REST API Reference for CreateWorkspaceBundle Operation
        public virtual IAsyncResult BeginCreateWorkspaceBundle(CreateWorkspaceBundleRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateWorkspaceBundleRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateWorkspaceBundleResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  CreateWorkspaceBundle operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginCreateWorkspaceBundle.
        /// 
        /// Returns a  CreateWorkspaceBundleResult from WorkSpaces.
        /// REST API Reference for CreateWorkspaceBundle Operation
        public virtual CreateWorkspaceBundleResponse EndCreateWorkspaceBundle(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  CreateWorkspaceImage
        /// 
        /// Creates a new WorkSpace image from an existing WorkSpace.
        /// 
        /// Container for the necessary parameters to execute the CreateWorkspaceImage service method.
        /// 
        /// The response from the CreateWorkspaceImage service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The state of the resource is not valid for this operation.
        /// 
        /// 
        /// This operation is not supported.
        /// 
        /// 
        /// The specified resource already exists.
        /// 
        /// 
        /// Your resource limits have been exceeded.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for CreateWorkspaceImage Operation
        public virtual CreateWorkspaceImageResponse CreateWorkspaceImage(CreateWorkspaceImageRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateWorkspaceImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateWorkspaceImageResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the CreateWorkspaceImage operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the CreateWorkspaceImage operation on AmazonWorkSpacesClient.
        /// 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 EndCreateWorkspaceImage
        ///         operation.
        /// REST API Reference for CreateWorkspaceImage Operation
        public virtual IAsyncResult BeginCreateWorkspaceImage(CreateWorkspaceImageRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateWorkspaceImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateWorkspaceImageResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  CreateWorkspaceImage operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginCreateWorkspaceImage.
        /// 
        /// Returns a  CreateWorkspaceImageResult from WorkSpaces.
        /// REST API Reference for CreateWorkspaceImage Operation
        public virtual CreateWorkspaceImageResponse EndCreateWorkspaceImage(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  CreateWorkspaces
        /// 
        /// Creates one or more WorkSpaces.
        /// 
        ///  
        /// 
        /// This operation is asynchronous and returns before the WorkSpaces are created.
        /// 
        ///   
        /// 
        /// TheMANUAL running mode value is only supported by Amazon WorkSpaces
        /// Core. Contact your account team to be allow-listed to use this value. For more information,
        /// see Amazon WorkSpaces Core.
        /// 
        ///  
        /// 
        /// Container for the necessary parameters to execute the CreateWorkspaces service method.
        /// 
        /// The response from the CreateWorkspaces service method, as returned by WorkSpaces.
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// Your resource limits have been exceeded.
        /// 
        /// REST API Reference for CreateWorkspaces Operation
        public virtual CreateWorkspacesResponse CreateWorkspaces(CreateWorkspacesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateWorkspacesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateWorkspacesResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the CreateWorkspaces operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the CreateWorkspaces operation on AmazonWorkSpacesClient.
        /// 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 EndCreateWorkspaces
        ///         operation.
        /// REST API Reference for CreateWorkspaces Operation
        public virtual IAsyncResult BeginCreateWorkspaces(CreateWorkspacesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateWorkspacesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateWorkspacesResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  CreateWorkspaces operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginCreateWorkspaces.
        /// 
        /// Returns a  CreateWorkspacesResult from WorkSpaces.
        /// REST API Reference for CreateWorkspaces Operation
        public virtual CreateWorkspacesResponse EndCreateWorkspaces(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  DeleteClientBranding
        /// 
        /// Deletes customized client branding. Client branding allows you to customize your WorkSpace's
        /// client login portal. You can tailor your login portal company logo, the support email
        /// address, support link, link to reset password, and a custom message for users trying
        /// to sign in.
        /// 
        ///  
        /// 
        /// After you delete your customized client branding, your login portal reverts to the
        /// default client branding.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DeleteClientBranding service method.
        /// 
        /// The response from the DeleteClientBranding service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for DeleteClientBranding Operation
        public virtual DeleteClientBrandingResponse DeleteClientBranding(DeleteClientBrandingRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteClientBrandingRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteClientBrandingResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the DeleteClientBranding operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DeleteClientBranding operation on AmazonWorkSpacesClient.
        /// 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 EndDeleteClientBranding
        ///         operation.
        /// REST API Reference for DeleteClientBranding Operation
        public virtual IAsyncResult BeginDeleteClientBranding(DeleteClientBrandingRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteClientBrandingRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteClientBrandingResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  DeleteClientBranding operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginDeleteClientBranding.
        /// 
        /// Returns a  DeleteClientBrandingResult from WorkSpaces.
        /// REST API Reference for DeleteClientBranding Operation
        public virtual DeleteClientBrandingResponse EndDeleteClientBranding(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  DeleteConnectClientAddIn
        /// 
        /// Deletes a client-add-in for Amazon Connect that is configured within a directory.
        /// 
        /// Container for the necessary parameters to execute the DeleteConnectClientAddIn service method.
        /// 
        /// The response from the DeleteConnectClientAddIn service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for DeleteConnectClientAddIn Operation
        public virtual DeleteConnectClientAddInResponse DeleteConnectClientAddIn(DeleteConnectClientAddInRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteConnectClientAddInRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteConnectClientAddInResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the DeleteConnectClientAddIn operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DeleteConnectClientAddIn operation on AmazonWorkSpacesClient.
        /// 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 EndDeleteConnectClientAddIn
        ///         operation.
        /// REST API Reference for DeleteConnectClientAddIn Operation
        public virtual IAsyncResult BeginDeleteConnectClientAddIn(DeleteConnectClientAddInRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteConnectClientAddInRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteConnectClientAddInResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  DeleteConnectClientAddIn operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginDeleteConnectClientAddIn.
        /// 
        /// Returns a  DeleteConnectClientAddInResult from WorkSpaces.
        /// REST API Reference for DeleteConnectClientAddIn Operation
        public virtual DeleteConnectClientAddInResponse EndDeleteConnectClientAddIn(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  DeleteConnectionAlias
        /// 
        /// Deletes the specified connection alias. For more information, see 
        /// Cross-Region Redirection for Amazon WorkSpaces.
        /// 
        ///   
        /// 
        ///  If you will no longer be using a fully qualified domain name (FQDN) as the registration
        /// code for your WorkSpaces users, you must take certain precautions to prevent potential
        /// security issues. For more information, see 
        /// Security Considerations if You Stop Using Cross-Region Redirection.
        /// 
        ///    
        /// 
        /// To delete a connection alias that has been shared, the shared account must first disassociate
        /// the connection alias from any directories it has been associated with. Then you must
        /// unshare the connection alias from the account it has been shared with. You can delete
        /// a connection alias only after it is no longer shared with any accounts or associated
        /// with any directories.
        /// 
        ///  
        /// 
        /// Container for the necessary parameters to execute the DeleteConnectionAlias service method.
        /// 
        /// The response from the DeleteConnectionAlias service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The state of the resource is not valid for this operation.
        /// 
        /// 
        /// This operation is not supported.
        /// 
        /// 
        /// The resource is associated with a directory.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for DeleteConnectionAlias Operation
        public virtual DeleteConnectionAliasResponse DeleteConnectionAlias(DeleteConnectionAliasRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteConnectionAliasRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteConnectionAliasResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the DeleteConnectionAlias operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DeleteConnectionAlias operation on AmazonWorkSpacesClient.
        /// 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 EndDeleteConnectionAlias
        ///         operation.
        /// REST API Reference for DeleteConnectionAlias Operation
        public virtual IAsyncResult BeginDeleteConnectionAlias(DeleteConnectionAliasRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteConnectionAliasRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteConnectionAliasResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  DeleteConnectionAlias operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginDeleteConnectionAlias.
        /// 
        /// Returns a  DeleteConnectionAliasResult from WorkSpaces.
        /// REST API Reference for DeleteConnectionAlias Operation
        public virtual DeleteConnectionAliasResponse EndDeleteConnectionAlias(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  DeleteIpGroup
        /// 
        /// Deletes the specified IP access control group.
        /// 
        ///  
        /// 
        /// You cannot delete an IP access control group that is associated with a directory.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DeleteIpGroup service method.
        /// 
        /// The response from the DeleteIpGroup service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The resource is associated with a directory.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for DeleteIpGroup Operation
        public virtual DeleteIpGroupResponse DeleteIpGroup(DeleteIpGroupRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteIpGroupRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteIpGroupResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the DeleteIpGroup operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DeleteIpGroup operation on AmazonWorkSpacesClient.
        /// 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 EndDeleteIpGroup
        ///         operation.
        /// REST API Reference for DeleteIpGroup Operation
        public virtual IAsyncResult BeginDeleteIpGroup(DeleteIpGroupRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteIpGroupRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteIpGroupResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  DeleteIpGroup operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginDeleteIpGroup.
        /// 
        /// Returns a  DeleteIpGroupResult from WorkSpaces.
        /// REST API Reference for DeleteIpGroup Operation
        public virtual DeleteIpGroupResponse EndDeleteIpGroup(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  DeleteTags
        /// 
        /// Deletes the specified tags from the specified WorkSpaces resource.
        /// 
        /// Container for the necessary parameters to execute the DeleteTags service method.
        /// 
        /// The response from the DeleteTags service method, as returned by WorkSpaces.
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for DeleteTags Operation
        public virtual DeleteTagsResponse DeleteTags(DeleteTagsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTagsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTagsResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the DeleteTags operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DeleteTags operation on AmazonWorkSpacesClient.
        /// 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 EndDeleteTags
        ///         operation.
        /// REST API Reference for DeleteTags Operation
        public virtual IAsyncResult BeginDeleteTags(DeleteTagsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTagsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTagsResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  DeleteTags operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginDeleteTags.
        /// 
        /// Returns a  DeleteTagsResult from WorkSpaces.
        /// REST API Reference for DeleteTags Operation
        public virtual DeleteTagsResponse EndDeleteTags(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  DeleteWorkspaceBundle
        /// 
        /// Deletes the specified WorkSpace bundle. For more information about deleting WorkSpace
        /// bundles, see 
        /// Delete a Custom WorkSpaces Bundle or Image.
        /// 
        /// Container for the necessary parameters to execute the DeleteWorkspaceBundle service method.
        /// 
        /// The response from the DeleteWorkspaceBundle service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The resource is associated with a directory.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for DeleteWorkspaceBundle Operation
        public virtual DeleteWorkspaceBundleResponse DeleteWorkspaceBundle(DeleteWorkspaceBundleRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteWorkspaceBundleRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteWorkspaceBundleResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the DeleteWorkspaceBundle operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DeleteWorkspaceBundle operation on AmazonWorkSpacesClient.
        /// 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 EndDeleteWorkspaceBundle
        ///         operation.
        /// REST API Reference for DeleteWorkspaceBundle Operation
        public virtual IAsyncResult BeginDeleteWorkspaceBundle(DeleteWorkspaceBundleRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteWorkspaceBundleRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteWorkspaceBundleResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  DeleteWorkspaceBundle operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginDeleteWorkspaceBundle.
        /// 
        /// Returns a  DeleteWorkspaceBundleResult from WorkSpaces.
        /// REST API Reference for DeleteWorkspaceBundle Operation
        public virtual DeleteWorkspaceBundleResponse EndDeleteWorkspaceBundle(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  DeleteWorkspaceImage
        /// 
        /// Deletes the specified image from your account. To delete an image, you must first
        /// delete any bundles that are associated with the image and unshare the image if it
        /// is shared with other accounts.
        /// 
        /// Container for the necessary parameters to execute the DeleteWorkspaceImage service method.
        /// 
        /// The response from the DeleteWorkspaceImage service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// The state of the resource is not valid for this operation.
        /// 
        /// 
        /// The resource is associated with a directory.
        /// 
        /// REST API Reference for DeleteWorkspaceImage Operation
        public virtual DeleteWorkspaceImageResponse DeleteWorkspaceImage(DeleteWorkspaceImageRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteWorkspaceImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteWorkspaceImageResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the DeleteWorkspaceImage operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DeleteWorkspaceImage operation on AmazonWorkSpacesClient.
        /// 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 EndDeleteWorkspaceImage
        ///         operation.
        /// REST API Reference for DeleteWorkspaceImage Operation
        public virtual IAsyncResult BeginDeleteWorkspaceImage(DeleteWorkspaceImageRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteWorkspaceImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteWorkspaceImageResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  DeleteWorkspaceImage operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginDeleteWorkspaceImage.
        /// 
        /// Returns a  DeleteWorkspaceImageResult from WorkSpaces.
        /// REST API Reference for DeleteWorkspaceImage Operation
        public virtual DeleteWorkspaceImageResponse EndDeleteWorkspaceImage(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  DeregisterWorkspaceDirectory
        /// 
        /// Deregisters the specified directory. This operation is asynchronous and returns before
        /// the WorkSpace directory is deregistered. If any WorkSpaces are registered to this
        /// directory, you must remove them before you can deregister the directory.
        /// 
        ///   
        /// 
        /// Simple AD and AD Connector are made available to you free of charge to use with WorkSpaces.
        /// If there are no WorkSpaces being used with your Simple AD or AD Connector directory
        /// for 30 consecutive days, this directory will be automatically deregistered for use
        /// with Amazon WorkSpaces, and you will be charged for this directory as per the Directory
        /// Service pricing terms.
        /// 
        ///  
        /// 
        /// To delete empty directories, see 
        /// Delete the Directory for Your WorkSpaces. If you delete your Simple AD or AD Connector
        /// directory, you can always create a new one when you want to start using WorkSpaces
        /// again.
        /// 
        ///  
        /// 
        /// Container for the necessary parameters to execute the DeregisterWorkspaceDirectory service method.
        /// 
        /// The response from the DeregisterWorkspaceDirectory service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The state of the resource is not valid for this operation.
        /// 
        /// 
        /// This operation is not supported.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for DeregisterWorkspaceDirectory Operation
        public virtual DeregisterWorkspaceDirectoryResponse DeregisterWorkspaceDirectory(DeregisterWorkspaceDirectoryRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeregisterWorkspaceDirectoryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeregisterWorkspaceDirectoryResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the DeregisterWorkspaceDirectory operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DeregisterWorkspaceDirectory operation on AmazonWorkSpacesClient.
        /// 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 EndDeregisterWorkspaceDirectory
        ///         operation.
        /// REST API Reference for DeregisterWorkspaceDirectory Operation
        public virtual IAsyncResult BeginDeregisterWorkspaceDirectory(DeregisterWorkspaceDirectoryRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeregisterWorkspaceDirectoryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeregisterWorkspaceDirectoryResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  DeregisterWorkspaceDirectory operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginDeregisterWorkspaceDirectory.
        /// 
        /// Returns a  DeregisterWorkspaceDirectoryResult from WorkSpaces.
        /// REST API Reference for DeregisterWorkspaceDirectory Operation
        public virtual DeregisterWorkspaceDirectoryResponse EndDeregisterWorkspaceDirectory(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  DescribeAccount
        /// 
        /// Retrieves a list that describes the configuration of Bring Your Own License (BYOL)
        /// for the specified account.
        /// 
        /// Container for the necessary parameters to execute the DescribeAccount service method.
        /// 
        /// The response from the DescribeAccount service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// REST API Reference for DescribeAccount Operation
        public virtual DescribeAccountResponse DescribeAccount(DescribeAccountRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeAccountRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeAccountResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the DescribeAccount operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DescribeAccount operation on AmazonWorkSpacesClient.
        /// 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 EndDescribeAccount
        ///         operation.
        /// REST API Reference for DescribeAccount Operation
        public virtual IAsyncResult BeginDescribeAccount(DescribeAccountRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeAccountRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeAccountResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  DescribeAccount operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginDescribeAccount.
        /// 
        /// Returns a  DescribeAccountResult from WorkSpaces.
        /// REST API Reference for DescribeAccount Operation
        public virtual DescribeAccountResponse EndDescribeAccount(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  DescribeAccountModifications
        /// 
        /// Retrieves a list that describes modifications to the configuration of Bring Your Own
        /// License (BYOL) for the specified account.
        /// 
        /// Container for the necessary parameters to execute the DescribeAccountModifications service method.
        /// 
        /// The response from the DescribeAccountModifications service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// REST API Reference for DescribeAccountModifications Operation
        public virtual DescribeAccountModificationsResponse DescribeAccountModifications(DescribeAccountModificationsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeAccountModificationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeAccountModificationsResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the DescribeAccountModifications operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DescribeAccountModifications operation on AmazonWorkSpacesClient.
        /// 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 EndDescribeAccountModifications
        ///         operation.
        /// REST API Reference for DescribeAccountModifications Operation
        public virtual IAsyncResult BeginDescribeAccountModifications(DescribeAccountModificationsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeAccountModificationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeAccountModificationsResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  DescribeAccountModifications operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginDescribeAccountModifications.
        /// 
        /// Returns a  DescribeAccountModificationsResult from WorkSpaces.
        /// REST API Reference for DescribeAccountModifications Operation
        public virtual DescribeAccountModificationsResponse EndDescribeAccountModifications(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  DescribeClientBranding
        /// 
        /// Describes the specified client branding. Client branding allows you to customize the
        /// log in page of various device types for your users. You can add your company logo,
        /// the support email address, support link, link to reset password, and a custom message
        /// for users trying to sign in.
        /// 
        ///   
        /// 
        /// Only device types that have branding information configured will be shown in the response.
        /// 
        ///  
        /// 
        /// Container for the necessary parameters to execute the DescribeClientBranding service method.
        /// 
        /// The response from the DescribeClientBranding service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for DescribeClientBranding Operation
        public virtual DescribeClientBrandingResponse DescribeClientBranding(DescribeClientBrandingRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeClientBrandingRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeClientBrandingResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the DescribeClientBranding operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DescribeClientBranding operation on AmazonWorkSpacesClient.
        /// 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 EndDescribeClientBranding
        ///         operation.
        /// REST API Reference for DescribeClientBranding Operation
        public virtual IAsyncResult BeginDescribeClientBranding(DescribeClientBrandingRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeClientBrandingRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeClientBrandingResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  DescribeClientBranding operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginDescribeClientBranding.
        /// 
        /// Returns a  DescribeClientBrandingResult from WorkSpaces.
        /// REST API Reference for DescribeClientBranding Operation
        public virtual DescribeClientBrandingResponse EndDescribeClientBranding(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  DescribeClientProperties
        /// 
        /// Retrieves a list that describes one or more specified Amazon WorkSpaces clients.
        /// 
        /// Container for the necessary parameters to execute the DescribeClientProperties service method.
        /// 
        /// The response from the DescribeClientProperties service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for DescribeClientProperties Operation
        public virtual DescribeClientPropertiesResponse DescribeClientProperties(DescribeClientPropertiesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeClientPropertiesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeClientPropertiesResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the DescribeClientProperties operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DescribeClientProperties operation on AmazonWorkSpacesClient.
        /// 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 EndDescribeClientProperties
        ///         operation.
        /// REST API Reference for DescribeClientProperties Operation
        public virtual IAsyncResult BeginDescribeClientProperties(DescribeClientPropertiesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeClientPropertiesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeClientPropertiesResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  DescribeClientProperties operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginDescribeClientProperties.
        /// 
        /// Returns a  DescribeClientPropertiesResult from WorkSpaces.
        /// REST API Reference for DescribeClientProperties Operation
        public virtual DescribeClientPropertiesResponse EndDescribeClientProperties(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  DescribeConnectClientAddIns
        /// 
        /// Retrieves a list of Amazon Connect client add-ins that have been created.
        /// 
        /// Container for the necessary parameters to execute the DescribeConnectClientAddIns service method.
        /// 
        /// The response from the DescribeConnectClientAddIns service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for DescribeConnectClientAddIns Operation
        public virtual DescribeConnectClientAddInsResponse DescribeConnectClientAddIns(DescribeConnectClientAddInsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeConnectClientAddInsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeConnectClientAddInsResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the DescribeConnectClientAddIns operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DescribeConnectClientAddIns operation on AmazonWorkSpacesClient.
        /// 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 EndDescribeConnectClientAddIns
        ///         operation.
        /// REST API Reference for DescribeConnectClientAddIns Operation
        public virtual IAsyncResult BeginDescribeConnectClientAddIns(DescribeConnectClientAddInsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeConnectClientAddInsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeConnectClientAddInsResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  DescribeConnectClientAddIns operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginDescribeConnectClientAddIns.
        /// 
        /// Returns a  DescribeConnectClientAddInsResult from WorkSpaces.
        /// REST API Reference for DescribeConnectClientAddIns Operation
        public virtual DescribeConnectClientAddInsResponse EndDescribeConnectClientAddIns(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  DescribeConnectionAliases
        /// 
        /// Retrieves a list that describes the connection aliases used for cross-Region redirection.
        /// For more information, see 
        /// Cross-Region Redirection for Amazon WorkSpaces.
        /// 
        /// Container for the necessary parameters to execute the DescribeConnectionAliases service method.
        /// 
        /// The response from the DescribeConnectionAliases service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// This operation is not supported.
        /// 
        /// REST API Reference for DescribeConnectionAliases Operation
        public virtual DescribeConnectionAliasesResponse DescribeConnectionAliases(DescribeConnectionAliasesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeConnectionAliasesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeConnectionAliasesResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the DescribeConnectionAliases operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DescribeConnectionAliases operation on AmazonWorkSpacesClient.
        /// 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 EndDescribeConnectionAliases
        ///         operation.
        /// REST API Reference for DescribeConnectionAliases Operation
        public virtual IAsyncResult BeginDescribeConnectionAliases(DescribeConnectionAliasesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeConnectionAliasesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeConnectionAliasesResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  DescribeConnectionAliases operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginDescribeConnectionAliases.
        /// 
        /// Returns a  DescribeConnectionAliasesResult from WorkSpaces.
        /// REST API Reference for DescribeConnectionAliases Operation
        public virtual DescribeConnectionAliasesResponse EndDescribeConnectionAliases(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  DescribeConnectionAliasPermissions
        /// 
        /// Describes the permissions that the owner of a connection alias has granted to another
        /// Amazon Web Services account for the specified connection alias. For more information,
        /// see 
        /// Cross-Region Redirection for Amazon WorkSpaces.
        /// 
        /// Container for the necessary parameters to execute the DescribeConnectionAliasPermissions service method.
        /// 
        /// The response from the DescribeConnectionAliasPermissions service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// This operation is not supported.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for DescribeConnectionAliasPermissions Operation
        public virtual DescribeConnectionAliasPermissionsResponse DescribeConnectionAliasPermissions(DescribeConnectionAliasPermissionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeConnectionAliasPermissionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeConnectionAliasPermissionsResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the DescribeConnectionAliasPermissions operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DescribeConnectionAliasPermissions operation on AmazonWorkSpacesClient.
        /// 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 EndDescribeConnectionAliasPermissions
        ///         operation.
        /// REST API Reference for DescribeConnectionAliasPermissions Operation
        public virtual IAsyncResult BeginDescribeConnectionAliasPermissions(DescribeConnectionAliasPermissionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeConnectionAliasPermissionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeConnectionAliasPermissionsResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  DescribeConnectionAliasPermissions operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginDescribeConnectionAliasPermissions.
        /// 
        /// Returns a  DescribeConnectionAliasPermissionsResult from WorkSpaces.
        /// REST API Reference for DescribeConnectionAliasPermissions Operation
        public virtual DescribeConnectionAliasPermissionsResponse EndDescribeConnectionAliasPermissions(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  DescribeIpGroups
        /// 
        /// Describes one or more of your IP access control groups.
        /// 
        /// Container for the necessary parameters to execute the DescribeIpGroups service method.
        /// 
        /// The response from the DescribeIpGroups service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// REST API Reference for DescribeIpGroups Operation
        public virtual DescribeIpGroupsResponse DescribeIpGroups(DescribeIpGroupsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeIpGroupsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeIpGroupsResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the DescribeIpGroups operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DescribeIpGroups operation on AmazonWorkSpacesClient.
        /// 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 EndDescribeIpGroups
        ///         operation.
        /// REST API Reference for DescribeIpGroups Operation
        public virtual IAsyncResult BeginDescribeIpGroups(DescribeIpGroupsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeIpGroupsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeIpGroupsResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  DescribeIpGroups operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginDescribeIpGroups.
        /// 
        /// Returns a  DescribeIpGroupsResult from WorkSpaces.
        /// REST API Reference for DescribeIpGroups Operation
        public virtual DescribeIpGroupsResponse EndDescribeIpGroups(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  DescribeTags
        /// 
        /// Describes the specified tags for the specified WorkSpaces resource.
        /// 
        /// Container for the necessary parameters to execute the DescribeTags service method.
        /// 
        /// The response from the DescribeTags service method, as returned by WorkSpaces.
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for DescribeTags Operation
        public virtual DescribeTagsResponse DescribeTags(DescribeTagsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTagsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTagsResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the DescribeTags operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DescribeTags operation on AmazonWorkSpacesClient.
        /// 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 EndDescribeTags
        ///         operation.
        /// REST API Reference for DescribeTags Operation
        public virtual IAsyncResult BeginDescribeTags(DescribeTagsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTagsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTagsResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  DescribeTags operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginDescribeTags.
        /// 
        /// Returns a  DescribeTagsResult from WorkSpaces.
        /// REST API Reference for DescribeTags Operation
        public virtual DescribeTagsResponse EndDescribeTags(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  DescribeWorkspaceBundles
        /// 
        /// Retrieves a list that describes the available WorkSpace bundles.
        /// 
        ///  
        /// 
        /// You can filter the results using either bundle ID or owner, but not both.
        /// 
        /// 
        /// 
        /// The response from the DescribeWorkspaceBundles service method, as returned by WorkSpaces.
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// REST API Reference for DescribeWorkspaceBundles Operation
        public virtual DescribeWorkspaceBundlesResponse DescribeWorkspaceBundles()
        {
            var request = new DescribeWorkspaceBundlesRequest();
            return DescribeWorkspaceBundles(request);
        }
        /// 
        /// Retrieves a list that describes the available WorkSpace bundles.
        /// 
        ///  
        /// 
        /// You can filter the results using either bundle ID or owner, but not both.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DescribeWorkspaceBundles service method.
        /// 
        /// The response from the DescribeWorkspaceBundles service method, as returned by WorkSpaces.
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// REST API Reference for DescribeWorkspaceBundles Operation
        public virtual DescribeWorkspaceBundlesResponse DescribeWorkspaceBundles(DescribeWorkspaceBundlesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeWorkspaceBundlesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeWorkspaceBundlesResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the DescribeWorkspaceBundles operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DescribeWorkspaceBundles operation on AmazonWorkSpacesClient.
        /// 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 EndDescribeWorkspaceBundles
        ///         operation.
        /// REST API Reference for DescribeWorkspaceBundles Operation
        public virtual IAsyncResult BeginDescribeWorkspaceBundles(DescribeWorkspaceBundlesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeWorkspaceBundlesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeWorkspaceBundlesResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  DescribeWorkspaceBundles operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginDescribeWorkspaceBundles.
        /// 
        /// Returns a  DescribeWorkspaceBundlesResult from WorkSpaces.
        /// REST API Reference for DescribeWorkspaceBundles Operation
        public virtual DescribeWorkspaceBundlesResponse EndDescribeWorkspaceBundles(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  DescribeWorkspaceDirectories
        /// 
        /// Describes the available directories that are registered with Amazon WorkSpaces.
        /// 
        /// 
        /// The response from the DescribeWorkspaceDirectories service method, as returned by WorkSpaces.
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// REST API Reference for DescribeWorkspaceDirectories Operation
        public virtual DescribeWorkspaceDirectoriesResponse DescribeWorkspaceDirectories()
        {
            var request = new DescribeWorkspaceDirectoriesRequest();
            return DescribeWorkspaceDirectories(request);
        }
        /// 
        /// Describes the available directories that are registered with Amazon WorkSpaces.
        /// 
        /// Container for the necessary parameters to execute the DescribeWorkspaceDirectories service method.
        /// 
        /// The response from the DescribeWorkspaceDirectories service method, as returned by WorkSpaces.
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// REST API Reference for DescribeWorkspaceDirectories Operation
        public virtual DescribeWorkspaceDirectoriesResponse DescribeWorkspaceDirectories(DescribeWorkspaceDirectoriesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeWorkspaceDirectoriesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeWorkspaceDirectoriesResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the DescribeWorkspaceDirectories operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DescribeWorkspaceDirectories operation on AmazonWorkSpacesClient.
        /// 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 EndDescribeWorkspaceDirectories
        ///         operation.
        /// REST API Reference for DescribeWorkspaceDirectories Operation
        public virtual IAsyncResult BeginDescribeWorkspaceDirectories(DescribeWorkspaceDirectoriesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeWorkspaceDirectoriesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeWorkspaceDirectoriesResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  DescribeWorkspaceDirectories operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginDescribeWorkspaceDirectories.
        /// 
        /// Returns a  DescribeWorkspaceDirectoriesResult from WorkSpaces.
        /// REST API Reference for DescribeWorkspaceDirectories Operation
        public virtual DescribeWorkspaceDirectoriesResponse EndDescribeWorkspaceDirectories(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  DescribeWorkspaceImagePermissions
        /// 
        /// Describes the permissions that the owner of an image has granted to other Amazon Web
        /// Services accounts for an image.
        /// 
        /// Container for the necessary parameters to execute the DescribeWorkspaceImagePermissions service method.
        /// 
        /// The response from the DescribeWorkspaceImagePermissions service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for DescribeWorkspaceImagePermissions Operation
        public virtual DescribeWorkspaceImagePermissionsResponse DescribeWorkspaceImagePermissions(DescribeWorkspaceImagePermissionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeWorkspaceImagePermissionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeWorkspaceImagePermissionsResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the DescribeWorkspaceImagePermissions operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DescribeWorkspaceImagePermissions operation on AmazonWorkSpacesClient.
        /// 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 EndDescribeWorkspaceImagePermissions
        ///         operation.
        /// REST API Reference for DescribeWorkspaceImagePermissions Operation
        public virtual IAsyncResult BeginDescribeWorkspaceImagePermissions(DescribeWorkspaceImagePermissionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeWorkspaceImagePermissionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeWorkspaceImagePermissionsResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  DescribeWorkspaceImagePermissions operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginDescribeWorkspaceImagePermissions.
        /// 
        /// Returns a  DescribeWorkspaceImagePermissionsResult from WorkSpaces.
        /// REST API Reference for DescribeWorkspaceImagePermissions Operation
        public virtual DescribeWorkspaceImagePermissionsResponse EndDescribeWorkspaceImagePermissions(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  DescribeWorkspaceImages
        /// 
        /// Retrieves a list that describes one or more specified images, if the image identifiers
        /// are provided. Otherwise, all images in the account are described.
        /// 
        /// Container for the necessary parameters to execute the DescribeWorkspaceImages service method.
        /// 
        /// The response from the DescribeWorkspaceImages service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// REST API Reference for DescribeWorkspaceImages Operation
        public virtual DescribeWorkspaceImagesResponse DescribeWorkspaceImages(DescribeWorkspaceImagesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeWorkspaceImagesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeWorkspaceImagesResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the DescribeWorkspaceImages operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DescribeWorkspaceImages operation on AmazonWorkSpacesClient.
        /// 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 EndDescribeWorkspaceImages
        ///         operation.
        /// REST API Reference for DescribeWorkspaceImages Operation
        public virtual IAsyncResult BeginDescribeWorkspaceImages(DescribeWorkspaceImagesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeWorkspaceImagesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeWorkspaceImagesResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  DescribeWorkspaceImages operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginDescribeWorkspaceImages.
        /// 
        /// Returns a  DescribeWorkspaceImagesResult from WorkSpaces.
        /// REST API Reference for DescribeWorkspaceImages Operation
        public virtual DescribeWorkspaceImagesResponse EndDescribeWorkspaceImages(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  DescribeWorkspaces
        /// 
        /// Describes the specified WorkSpaces.
        /// 
        ///  
        /// 
        /// You can filter the results by using the bundle identifier, directory identifier, or
        /// owner, but you can specify only one filter at a time.
        /// 
        /// 
        /// 
        /// The response from the DescribeWorkspaces service method, as returned by WorkSpaces.
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The specified resource is not available.
        /// 
        /// REST API Reference for DescribeWorkspaces Operation
        public virtual DescribeWorkspacesResponse DescribeWorkspaces()
        {
            var request = new DescribeWorkspacesRequest();
            return DescribeWorkspaces(request);
        }
        /// 
        /// Describes the specified WorkSpaces.
        /// 
        ///  
        /// 
        /// You can filter the results by using the bundle identifier, directory identifier, or
        /// owner, but you can specify only one filter at a time.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DescribeWorkspaces service method.
        /// 
        /// The response from the DescribeWorkspaces service method, as returned by WorkSpaces.
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The specified resource is not available.
        /// 
        /// REST API Reference for DescribeWorkspaces Operation
        public virtual DescribeWorkspacesResponse DescribeWorkspaces(DescribeWorkspacesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeWorkspacesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeWorkspacesResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the DescribeWorkspaces operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DescribeWorkspaces operation on AmazonWorkSpacesClient.
        /// 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 EndDescribeWorkspaces
        ///         operation.
        /// REST API Reference for DescribeWorkspaces Operation
        public virtual IAsyncResult BeginDescribeWorkspaces(DescribeWorkspacesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeWorkspacesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeWorkspacesResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  DescribeWorkspaces operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginDescribeWorkspaces.
        /// 
        /// Returns a  DescribeWorkspacesResult from WorkSpaces.
        /// REST API Reference for DescribeWorkspaces Operation
        public virtual DescribeWorkspacesResponse EndDescribeWorkspaces(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  DescribeWorkspacesConnectionStatus
        /// 
        /// Describes the connection status of the specified WorkSpaces.
        /// 
        /// Container for the necessary parameters to execute the DescribeWorkspacesConnectionStatus service method.
        /// 
        /// The response from the DescribeWorkspacesConnectionStatus service method, as returned by WorkSpaces.
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// REST API Reference for DescribeWorkspacesConnectionStatus Operation
        public virtual DescribeWorkspacesConnectionStatusResponse DescribeWorkspacesConnectionStatus(DescribeWorkspacesConnectionStatusRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeWorkspacesConnectionStatusRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeWorkspacesConnectionStatusResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the DescribeWorkspacesConnectionStatus operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DescribeWorkspacesConnectionStatus operation on AmazonWorkSpacesClient.
        /// 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 EndDescribeWorkspacesConnectionStatus
        ///         operation.
        /// REST API Reference for DescribeWorkspacesConnectionStatus Operation
        public virtual IAsyncResult BeginDescribeWorkspacesConnectionStatus(DescribeWorkspacesConnectionStatusRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeWorkspacesConnectionStatusRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeWorkspacesConnectionStatusResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  DescribeWorkspacesConnectionStatus operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginDescribeWorkspacesConnectionStatus.
        /// 
        /// Returns a  DescribeWorkspacesConnectionStatusResult from WorkSpaces.
        /// REST API Reference for DescribeWorkspacesConnectionStatus Operation
        public virtual DescribeWorkspacesConnectionStatusResponse EndDescribeWorkspacesConnectionStatus(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  DescribeWorkspaceSnapshots
        /// 
        /// Describes the snapshots for the specified WorkSpace.
        /// 
        /// Container for the necessary parameters to execute the DescribeWorkspaceSnapshots service method.
        /// 
        /// The response from the DescribeWorkspaceSnapshots service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for DescribeWorkspaceSnapshots Operation
        public virtual DescribeWorkspaceSnapshotsResponse DescribeWorkspaceSnapshots(DescribeWorkspaceSnapshotsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeWorkspaceSnapshotsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeWorkspaceSnapshotsResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the DescribeWorkspaceSnapshots operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DescribeWorkspaceSnapshots operation on AmazonWorkSpacesClient.
        /// 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 EndDescribeWorkspaceSnapshots
        ///         operation.
        /// REST API Reference for DescribeWorkspaceSnapshots Operation
        public virtual IAsyncResult BeginDescribeWorkspaceSnapshots(DescribeWorkspaceSnapshotsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeWorkspaceSnapshotsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeWorkspaceSnapshotsResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  DescribeWorkspaceSnapshots operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginDescribeWorkspaceSnapshots.
        /// 
        /// Returns a  DescribeWorkspaceSnapshotsResult from WorkSpaces.
        /// REST API Reference for DescribeWorkspaceSnapshots Operation
        public virtual DescribeWorkspaceSnapshotsResponse EndDescribeWorkspaceSnapshots(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  DisassociateConnectionAlias
        /// 
        /// Disassociates a connection alias from a directory. Disassociating a connection alias
        /// disables cross-Region redirection between two directories in different Regions. For
        /// more information, see 
        /// Cross-Region Redirection for Amazon WorkSpaces.
        /// 
        ///   
        /// 
        /// Before performing this operation, call 
        /// DescribeConnectionAliases to make sure that the current state of the connection
        /// alias is CREATED.
        /// 
        ///  
        /// 
        /// Container for the necessary parameters to execute the DisassociateConnectionAlias service method.
        /// 
        /// The response from the DisassociateConnectionAlias service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The state of the resource is not valid for this operation.
        /// 
        /// 
        /// This operation is not supported.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for DisassociateConnectionAlias Operation
        public virtual DisassociateConnectionAliasResponse DisassociateConnectionAlias(DisassociateConnectionAliasRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateConnectionAliasRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateConnectionAliasResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the DisassociateConnectionAlias operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DisassociateConnectionAlias operation on AmazonWorkSpacesClient.
        /// 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 EndDisassociateConnectionAlias
        ///         operation.
        /// REST API Reference for DisassociateConnectionAlias Operation
        public virtual IAsyncResult BeginDisassociateConnectionAlias(DisassociateConnectionAliasRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateConnectionAliasRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateConnectionAliasResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  DisassociateConnectionAlias operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginDisassociateConnectionAlias.
        /// 
        /// Returns a  DisassociateConnectionAliasResult from WorkSpaces.
        /// REST API Reference for DisassociateConnectionAlias Operation
        public virtual DisassociateConnectionAliasResponse EndDisassociateConnectionAlias(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  DisassociateIpGroups
        /// 
        /// Disassociates the specified IP access control group from the specified directory.
        /// 
        /// Container for the necessary parameters to execute the DisassociateIpGroups service method.
        /// 
        /// The response from the DisassociateIpGroups service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The state of the resource is not valid for this operation.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for DisassociateIpGroups Operation
        public virtual DisassociateIpGroupsResponse DisassociateIpGroups(DisassociateIpGroupsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateIpGroupsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateIpGroupsResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the DisassociateIpGroups operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DisassociateIpGroups operation on AmazonWorkSpacesClient.
        /// 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 EndDisassociateIpGroups
        ///         operation.
        /// REST API Reference for DisassociateIpGroups Operation
        public virtual IAsyncResult BeginDisassociateIpGroups(DisassociateIpGroupsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateIpGroupsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateIpGroupsResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  DisassociateIpGroups operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginDisassociateIpGroups.
        /// 
        /// Returns a  DisassociateIpGroupsResult from WorkSpaces.
        /// REST API Reference for DisassociateIpGroups Operation
        public virtual DisassociateIpGroupsResponse EndDisassociateIpGroups(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  ImportClientBranding
        /// 
        /// Imports client branding. Client branding allows you to customize your WorkSpace's
        /// client login portal. You can tailor your login portal company logo, the support email
        /// address, support link, link to reset password, and a custom message for users trying
        /// to sign in.
        /// 
        ///  
        /// 
        /// After you import client branding, the default branding experience for the specified
        /// platform type is replaced with the imported experience
        /// 
        ///    -  
        /// 
        /// You must specify at least one platform type when importing client branding.
        /// 
        ///  
-  
        /// 
        /// You can import up to 6 MB of data with each request. If your request exceeds this
        /// limit, you can import client branding for different platform types using separate
        /// requests.
        /// 
        ///  
-  
        /// 
        /// In each platform type, the SupportEmailandSupportLink/// parameters are mutually exclusive. You can specify only one parameter for each platform
        /// type, but not both.
        /// 
        ///
-  
        /// 
        /// Imported data can take up to a minute to appear in the WorkSpaces client.
        /// 
        ///  
/// 
        /// Container for the necessary parameters to execute the ImportClientBranding service method.
        /// 
        /// The response from the ImportClientBranding service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// Your resource limits have been exceeded.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for ImportClientBranding Operation
        public virtual ImportClientBrandingResponse ImportClientBranding(ImportClientBrandingRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ImportClientBrandingRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ImportClientBrandingResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the ImportClientBranding operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the ImportClientBranding operation on AmazonWorkSpacesClient.
        /// 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 EndImportClientBranding
        ///         operation.
        /// REST API Reference for ImportClientBranding Operation
        public virtual IAsyncResult BeginImportClientBranding(ImportClientBrandingRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ImportClientBrandingRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ImportClientBrandingResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  ImportClientBranding operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginImportClientBranding.
        /// 
        /// Returns a  ImportClientBrandingResult from WorkSpaces.
        /// REST API Reference for ImportClientBranding Operation
        public virtual ImportClientBrandingResponse EndImportClientBranding(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  ImportWorkspaceImage
        /// 
        /// Imports the specified Windows 10 or 11 Bring Your Own License (BYOL) image into Amazon
        /// WorkSpaces. The image must be an already licensed Amazon EC2 image that is in your
        /// Amazon Web Services account, and you must own the image. For more information about
        /// creating BYOL images, see 
        /// Bring Your Own Windows Desktop Licenses.
        /// 
        /// Container for the necessary parameters to execute the ImportWorkspaceImage service method.
        /// 
        /// The response from the ImportWorkspaceImage service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// This operation is not supported.
        /// 
        /// 
        /// The specified resource already exists.
        /// 
        /// 
        /// Your resource limits have been exceeded.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for ImportWorkspaceImage Operation
        public virtual ImportWorkspaceImageResponse ImportWorkspaceImage(ImportWorkspaceImageRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ImportWorkspaceImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ImportWorkspaceImageResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the ImportWorkspaceImage operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the ImportWorkspaceImage operation on AmazonWorkSpacesClient.
        /// 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 EndImportWorkspaceImage
        ///         operation.
        /// REST API Reference for ImportWorkspaceImage Operation
        public virtual IAsyncResult BeginImportWorkspaceImage(ImportWorkspaceImageRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ImportWorkspaceImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ImportWorkspaceImageResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  ImportWorkspaceImage operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginImportWorkspaceImage.
        /// 
        /// Returns a  ImportWorkspaceImageResult from WorkSpaces.
        /// REST API Reference for ImportWorkspaceImage Operation
        public virtual ImportWorkspaceImageResponse EndImportWorkspaceImage(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  ListAvailableManagementCidrRanges
        /// 
        /// Retrieves a list of IP address ranges, specified as IPv4 CIDR blocks, that you can
        /// use for the network management interface when you enable Bring Your Own License (BYOL).
        /// 
        /// 
        ///  
        /// 
        /// This operation can be run only by Amazon Web Services accounts that are enabled for
        /// BYOL. If your account isn't enabled for BYOL, you'll receive anAccessDeniedException
        /// error.
        /// 
        ///  
        /// 
        /// The management network interface is connected to a secure Amazon WorkSpaces management
        /// network. It is used for interactive streaming of the WorkSpace desktop to Amazon WorkSpaces
        /// clients, and to allow Amazon WorkSpaces to manage the WorkSpace.
        /// 
        /// 
        /// Container for the necessary parameters to execute the ListAvailableManagementCidrRanges service method.
        /// 
        /// The response from the ListAvailableManagementCidrRanges service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// REST API Reference for ListAvailableManagementCidrRanges Operation
        public virtual ListAvailableManagementCidrRangesResponse ListAvailableManagementCidrRanges(ListAvailableManagementCidrRangesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListAvailableManagementCidrRangesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListAvailableManagementCidrRangesResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the ListAvailableManagementCidrRanges operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the ListAvailableManagementCidrRanges operation on AmazonWorkSpacesClient.
        /// 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 EndListAvailableManagementCidrRanges
        ///         operation.
        /// REST API Reference for ListAvailableManagementCidrRanges Operation
        public virtual IAsyncResult BeginListAvailableManagementCidrRanges(ListAvailableManagementCidrRangesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListAvailableManagementCidrRangesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListAvailableManagementCidrRangesResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  ListAvailableManagementCidrRanges operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginListAvailableManagementCidrRanges.
        /// 
        /// Returns a  ListAvailableManagementCidrRangesResult from WorkSpaces.
        /// REST API Reference for ListAvailableManagementCidrRanges Operation
        public virtual ListAvailableManagementCidrRangesResponse EndListAvailableManagementCidrRanges(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  MigrateWorkspace
        /// 
        /// Migrates a WorkSpace from one operating system or bundle type to another, while retaining
        /// the data on the user volume.
        /// 
        ///  
        /// 
        /// The migration process recreates the WorkSpace by using a new root volume from the
        /// target bundle image and the user volume from the last available snapshot of the original
        /// WorkSpace. During migration, the original D:\Users\%USERNAME% user profile
        /// folder is renamed to D:\Users\%USERNAME%MMddyyTHHmmss%.NotMigrated. A
        /// new D:\Users\%USERNAME%\ folder is generated by the new OS. Certain files
        /// in the old user profile are moved to the new user profile.
        /// 
        ///  
        /// 
        /// For available migration scenarios, details about what happens during migration, and
        /// best practices, see Migrate
        /// a WorkSpace.
        /// 
        /// 
        /// Container for the necessary parameters to execute the MigrateWorkspace service method.
        /// 
        /// The response from the MigrateWorkspace service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The properties of this WorkSpace are currently being modified. Try again in a moment.
        /// 
        /// 
        /// This operation is not supported.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// 
        /// The specified resource is not available.
        /// 
        /// REST API Reference for MigrateWorkspace Operation
        public virtual MigrateWorkspaceResponse MigrateWorkspace(MigrateWorkspaceRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = MigrateWorkspaceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = MigrateWorkspaceResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the MigrateWorkspace operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the MigrateWorkspace operation on AmazonWorkSpacesClient.
        /// 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 EndMigrateWorkspace
        ///         operation.
        /// REST API Reference for MigrateWorkspace Operation
        public virtual IAsyncResult BeginMigrateWorkspace(MigrateWorkspaceRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = MigrateWorkspaceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = MigrateWorkspaceResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  MigrateWorkspace operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginMigrateWorkspace.
        /// 
        /// Returns a  MigrateWorkspaceResult from WorkSpaces.
        /// REST API Reference for MigrateWorkspace Operation
        public virtual MigrateWorkspaceResponse EndMigrateWorkspace(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  ModifyAccount
        /// 
        /// Modifies the configuration of Bring Your Own License (BYOL) for the specified account.
        /// 
        /// Container for the necessary parameters to execute the ModifyAccount service method.
        /// 
        /// The response from the ModifyAccount service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The state of the resource is not valid for this operation.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// 
        /// The specified resource is not available.
        /// 
        /// REST API Reference for ModifyAccount Operation
        public virtual ModifyAccountResponse ModifyAccount(ModifyAccountRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyAccountRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyAccountResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the ModifyAccount operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the ModifyAccount operation on AmazonWorkSpacesClient.
        /// 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 EndModifyAccount
        ///         operation.
        /// REST API Reference for ModifyAccount Operation
        public virtual IAsyncResult BeginModifyAccount(ModifyAccountRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyAccountRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyAccountResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  ModifyAccount operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginModifyAccount.
        /// 
        /// Returns a  ModifyAccountResult from WorkSpaces.
        /// REST API Reference for ModifyAccount Operation
        public virtual ModifyAccountResponse EndModifyAccount(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  ModifyCertificateBasedAuthProperties
        /// 
        /// Modifies the properties of the certificate-based authentication you want to use with
        /// your WorkSpaces.
        /// 
        /// Container for the necessary parameters to execute the ModifyCertificateBasedAuthProperties service method.
        /// 
        /// The response from the ModifyCertificateBasedAuthProperties service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// This operation is not supported.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for ModifyCertificateBasedAuthProperties Operation
        public virtual ModifyCertificateBasedAuthPropertiesResponse ModifyCertificateBasedAuthProperties(ModifyCertificateBasedAuthPropertiesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyCertificateBasedAuthPropertiesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyCertificateBasedAuthPropertiesResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the ModifyCertificateBasedAuthProperties operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the ModifyCertificateBasedAuthProperties operation on AmazonWorkSpacesClient.
        /// 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 EndModifyCertificateBasedAuthProperties
        ///         operation.
        /// REST API Reference for ModifyCertificateBasedAuthProperties Operation
        public virtual IAsyncResult BeginModifyCertificateBasedAuthProperties(ModifyCertificateBasedAuthPropertiesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyCertificateBasedAuthPropertiesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyCertificateBasedAuthPropertiesResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  ModifyCertificateBasedAuthProperties operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginModifyCertificateBasedAuthProperties.
        /// 
        /// Returns a  ModifyCertificateBasedAuthPropertiesResult from WorkSpaces.
        /// REST API Reference for ModifyCertificateBasedAuthProperties Operation
        public virtual ModifyCertificateBasedAuthPropertiesResponse EndModifyCertificateBasedAuthProperties(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  ModifyClientProperties
        /// 
        /// Modifies the properties of the specified Amazon WorkSpaces clients.
        /// 
        /// Container for the necessary parameters to execute the ModifyClientProperties service method.
        /// 
        /// The response from the ModifyClientProperties service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for ModifyClientProperties Operation
        public virtual ModifyClientPropertiesResponse ModifyClientProperties(ModifyClientPropertiesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyClientPropertiesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyClientPropertiesResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the ModifyClientProperties operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the ModifyClientProperties operation on AmazonWorkSpacesClient.
        /// 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 EndModifyClientProperties
        ///         operation.
        /// REST API Reference for ModifyClientProperties Operation
        public virtual IAsyncResult BeginModifyClientProperties(ModifyClientPropertiesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyClientPropertiesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyClientPropertiesResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  ModifyClientProperties operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginModifyClientProperties.
        /// 
        /// Returns a  ModifyClientPropertiesResult from WorkSpaces.
        /// REST API Reference for ModifyClientProperties Operation
        public virtual ModifyClientPropertiesResponse EndModifyClientProperties(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  ModifySamlProperties
        /// 
        /// Modifies multiple properties related to SAML 2.0 authentication, including the enablement
        /// status, user access URL, and relay state parameter name that are used for configuring
        /// federation with an SAML 2.0 identity provider.
        /// 
        /// Container for the necessary parameters to execute the ModifySamlProperties service method.
        /// 
        /// The response from the ModifySamlProperties service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// This operation is not supported.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for ModifySamlProperties Operation
        public virtual ModifySamlPropertiesResponse ModifySamlProperties(ModifySamlPropertiesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifySamlPropertiesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifySamlPropertiesResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the ModifySamlProperties operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the ModifySamlProperties operation on AmazonWorkSpacesClient.
        /// 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 EndModifySamlProperties
        ///         operation.
        /// REST API Reference for ModifySamlProperties Operation
        public virtual IAsyncResult BeginModifySamlProperties(ModifySamlPropertiesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifySamlPropertiesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifySamlPropertiesResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  ModifySamlProperties operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginModifySamlProperties.
        /// 
        /// Returns a  ModifySamlPropertiesResult from WorkSpaces.
        /// REST API Reference for ModifySamlProperties Operation
        public virtual ModifySamlPropertiesResponse EndModifySamlProperties(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  ModifySelfservicePermissions
        /// 
        /// Modifies the self-service WorkSpace management capabilities for your users. For more
        /// information, see Enable
        /// Self-Service WorkSpace Management Capabilities for Your Users.
        /// 
        /// Container for the necessary parameters to execute the ModifySelfservicePermissions service method.
        /// 
        /// The response from the ModifySelfservicePermissions service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for ModifySelfservicePermissions Operation
        public virtual ModifySelfservicePermissionsResponse ModifySelfservicePermissions(ModifySelfservicePermissionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifySelfservicePermissionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifySelfservicePermissionsResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the ModifySelfservicePermissions operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the ModifySelfservicePermissions operation on AmazonWorkSpacesClient.
        /// 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 EndModifySelfservicePermissions
        ///         operation.
        /// REST API Reference for ModifySelfservicePermissions Operation
        public virtual IAsyncResult BeginModifySelfservicePermissions(ModifySelfservicePermissionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifySelfservicePermissionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifySelfservicePermissionsResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  ModifySelfservicePermissions operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginModifySelfservicePermissions.
        /// 
        /// Returns a  ModifySelfservicePermissionsResult from WorkSpaces.
        /// REST API Reference for ModifySelfservicePermissions Operation
        public virtual ModifySelfservicePermissionsResponse EndModifySelfservicePermissions(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  ModifyWorkspaceAccessProperties
        /// 
        /// Specifies which devices and operating systems users can use to access their WorkSpaces.
        /// For more information, see 
        /// Control Device Access.
        /// 
        /// Container for the necessary parameters to execute the ModifyWorkspaceAccessProperties service method.
        /// 
        /// The response from the ModifyWorkspaceAccessProperties service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for ModifyWorkspaceAccessProperties Operation
        public virtual ModifyWorkspaceAccessPropertiesResponse ModifyWorkspaceAccessProperties(ModifyWorkspaceAccessPropertiesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyWorkspaceAccessPropertiesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyWorkspaceAccessPropertiesResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the ModifyWorkspaceAccessProperties operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the ModifyWorkspaceAccessProperties operation on AmazonWorkSpacesClient.
        /// 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 EndModifyWorkspaceAccessProperties
        ///         operation.
        /// REST API Reference for ModifyWorkspaceAccessProperties Operation
        public virtual IAsyncResult BeginModifyWorkspaceAccessProperties(ModifyWorkspaceAccessPropertiesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyWorkspaceAccessPropertiesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyWorkspaceAccessPropertiesResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  ModifyWorkspaceAccessProperties operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginModifyWorkspaceAccessProperties.
        /// 
        /// Returns a  ModifyWorkspaceAccessPropertiesResult from WorkSpaces.
        /// REST API Reference for ModifyWorkspaceAccessProperties Operation
        public virtual ModifyWorkspaceAccessPropertiesResponse EndModifyWorkspaceAccessProperties(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  ModifyWorkspaceCreationProperties
        /// 
        /// Modify the default properties used to create WorkSpaces.
        /// 
        /// Container for the necessary parameters to execute the ModifyWorkspaceCreationProperties service method.
        /// 
        /// The response from the ModifyWorkspaceCreationProperties service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// This operation is not supported.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for ModifyWorkspaceCreationProperties Operation
        public virtual ModifyWorkspaceCreationPropertiesResponse ModifyWorkspaceCreationProperties(ModifyWorkspaceCreationPropertiesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyWorkspaceCreationPropertiesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyWorkspaceCreationPropertiesResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the ModifyWorkspaceCreationProperties operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the ModifyWorkspaceCreationProperties operation on AmazonWorkSpacesClient.
        /// 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 EndModifyWorkspaceCreationProperties
        ///         operation.
        /// REST API Reference for ModifyWorkspaceCreationProperties Operation
        public virtual IAsyncResult BeginModifyWorkspaceCreationProperties(ModifyWorkspaceCreationPropertiesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyWorkspaceCreationPropertiesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyWorkspaceCreationPropertiesResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  ModifyWorkspaceCreationProperties operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginModifyWorkspaceCreationProperties.
        /// 
        /// Returns a  ModifyWorkspaceCreationPropertiesResult from WorkSpaces.
        /// REST API Reference for ModifyWorkspaceCreationProperties Operation
        public virtual ModifyWorkspaceCreationPropertiesResponse EndModifyWorkspaceCreationProperties(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  ModifyWorkspaceProperties
        /// 
        /// Modifies the specified WorkSpace properties. For important information about how to
        /// modify the size of the root and user volumes, see 
        /// Modify a WorkSpace. 
        /// 
        ///   
        /// 
        /// The MANUAL running mode value is only supported by Amazon WorkSpaces
        /// Core. Contact your account team to be allow-listed to use this value. For more information,
        /// see Amazon WorkSpaces Core.
        /// 
        ///  
        /// 
        /// Container for the necessary parameters to execute the ModifyWorkspaceProperties service method.
        /// 
        /// The response from the ModifyWorkspaceProperties service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The state of the resource is not valid for this operation.
        /// 
        /// 
        /// The properties of this WorkSpace are currently being modified. Try again in a moment.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// 
        /// The specified resource is not available.
        /// 
        /// 
        /// The configuration of this WorkSpace is not supported for this operation. For more
        /// information, see Required
        /// Configuration and Service Components for WorkSpaces .
        /// 
        /// REST API Reference for ModifyWorkspaceProperties Operation
        public virtual ModifyWorkspacePropertiesResponse ModifyWorkspaceProperties(ModifyWorkspacePropertiesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyWorkspacePropertiesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyWorkspacePropertiesResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the ModifyWorkspaceProperties operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the ModifyWorkspaceProperties operation on AmazonWorkSpacesClient.
        /// 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 EndModifyWorkspaceProperties
        ///         operation.
        /// REST API Reference for ModifyWorkspaceProperties Operation
        public virtual IAsyncResult BeginModifyWorkspaceProperties(ModifyWorkspacePropertiesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyWorkspacePropertiesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyWorkspacePropertiesResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  ModifyWorkspaceProperties operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginModifyWorkspaceProperties.
        /// 
        /// Returns a  ModifyWorkspacePropertiesResult from WorkSpaces.
        /// REST API Reference for ModifyWorkspaceProperties Operation
        public virtual ModifyWorkspacePropertiesResponse EndModifyWorkspaceProperties(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  ModifyWorkspaceState
        /// 
        /// Sets the state of the specified WorkSpace.
        /// 
        ///  
        /// 
        /// To maintain a WorkSpace without being interrupted, set the WorkSpace state to ADMIN_MAINTENANCE.
        /// WorkSpaces in this state do not respond to requests to reboot, stop, start, rebuild,
        /// or restore. An AutoStop WorkSpace in this state is not stopped. Users cannot log into
        /// a WorkSpace in the ADMIN_MAINTENANCE state.
        /// 
        /// 
        /// Container for the necessary parameters to execute the ModifyWorkspaceState service method.
        /// 
        /// The response from the ModifyWorkspaceState service method, as returned by WorkSpaces.
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The state of the resource is not valid for this operation.
        /// 
        /// 
        /// This operation is not supported.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for ModifyWorkspaceState Operation
        public virtual ModifyWorkspaceStateResponse ModifyWorkspaceState(ModifyWorkspaceStateRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyWorkspaceStateRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyWorkspaceStateResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the ModifyWorkspaceState operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the ModifyWorkspaceState operation on AmazonWorkSpacesClient.
        /// 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 EndModifyWorkspaceState
        ///         operation.
        /// REST API Reference for ModifyWorkspaceState Operation
        public virtual IAsyncResult BeginModifyWorkspaceState(ModifyWorkspaceStateRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyWorkspaceStateRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyWorkspaceStateResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  ModifyWorkspaceState operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginModifyWorkspaceState.
        /// 
        /// Returns a  ModifyWorkspaceStateResult from WorkSpaces.
        /// REST API Reference for ModifyWorkspaceState Operation
        public virtual ModifyWorkspaceStateResponse EndModifyWorkspaceState(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  RebootWorkspaces
        /// 
        /// Reboots the specified WorkSpaces.
        /// 
        ///  
        /// 
        /// You cannot reboot a WorkSpace unless its state is AVAILABLE or UNHEALTHY.
        /// 
        ///  
        /// 
        /// This operation is asynchronous and returns before the WorkSpaces have rebooted.
        /// 
        /// 
        /// Container for the necessary parameters to execute the RebootWorkspaces service method.
        /// 
        /// The response from the RebootWorkspaces service method, as returned by WorkSpaces.
        /// 
        /// This operation is not supported.
        /// 
        /// REST API Reference for RebootWorkspaces Operation
        public virtual RebootWorkspacesResponse RebootWorkspaces(RebootWorkspacesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RebootWorkspacesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RebootWorkspacesResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the RebootWorkspaces operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the RebootWorkspaces operation on AmazonWorkSpacesClient.
        /// 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 EndRebootWorkspaces
        ///         operation.
        /// REST API Reference for RebootWorkspaces Operation
        public virtual IAsyncResult BeginRebootWorkspaces(RebootWorkspacesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RebootWorkspacesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RebootWorkspacesResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  RebootWorkspaces operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginRebootWorkspaces.
        /// 
        /// Returns a  RebootWorkspacesResult from WorkSpaces.
        /// REST API Reference for RebootWorkspaces Operation
        public virtual RebootWorkspacesResponse EndRebootWorkspaces(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  RebuildWorkspaces
        /// 
        /// Rebuilds the specified WorkSpace.
        /// 
        ///  
        /// 
        /// You cannot rebuild a WorkSpace unless its state is AVAILABLE, ERROR,
        /// UNHEALTHY, STOPPED, or REBOOTING.
        /// 
        ///  
        /// 
        /// Rebuilding a WorkSpace is a potentially destructive action that can result in the
        /// loss of data. For more information, see Rebuild
        /// a WorkSpace.
        /// 
        ///  
        /// 
        /// This operation is asynchronous and returns before the WorkSpaces have been completely
        /// rebuilt.
        /// 
        /// 
        /// Container for the necessary parameters to execute the RebuildWorkspaces service method.
        /// 
        /// The response from the RebuildWorkspaces service method, as returned by WorkSpaces.
        /// 
        /// This operation is not supported.
        /// 
        /// REST API Reference for RebuildWorkspaces Operation
        public virtual RebuildWorkspacesResponse RebuildWorkspaces(RebuildWorkspacesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RebuildWorkspacesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RebuildWorkspacesResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the RebuildWorkspaces operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the RebuildWorkspaces operation on AmazonWorkSpacesClient.
        /// 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 EndRebuildWorkspaces
        ///         operation.
        /// REST API Reference for RebuildWorkspaces Operation
        public virtual IAsyncResult BeginRebuildWorkspaces(RebuildWorkspacesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RebuildWorkspacesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RebuildWorkspacesResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  RebuildWorkspaces operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginRebuildWorkspaces.
        /// 
        /// Returns a  RebuildWorkspacesResult from WorkSpaces.
        /// REST API Reference for RebuildWorkspaces Operation
        public virtual RebuildWorkspacesResponse EndRebuildWorkspaces(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  RegisterWorkspaceDirectory
        /// 
        /// Registers the specified directory. This operation is asynchronous and returns before
        /// the WorkSpace directory is registered. If this is the first time you are registering
        /// a directory, you will need to create the workspaces_DefaultRole role before you can
        /// register a directory. For more information, see 
        /// Creating the workspaces_DefaultRole Role.
        /// 
        /// Container for the necessary parameters to execute the RegisterWorkspaceDirectory service method.
        /// 
        /// The response from the RegisterWorkspaceDirectory service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The state of the resource is not valid for this operation.
        /// 
        /// 
        /// This operation is not supported.
        /// 
        /// 
        /// Your resource limits have been exceeded.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// 
        /// The configuration of this network is not supported for this operation, or your network
        /// configuration conflicts with the Amazon WorkSpaces management network IP range. For
        /// more information, see 
        /// Configure a VPC for Amazon WorkSpaces.
        /// 
        /// 
        /// The workspaces_DefaultRole role could not be found. If this is the first time you
        /// are registering a directory, you will need to create the workspaces_DefaultRole role
        /// before you can register a directory. For more information, see Creating
        /// the workspaces_DefaultRole Role.
        /// 
        /// REST API Reference for RegisterWorkspaceDirectory Operation
        public virtual RegisterWorkspaceDirectoryResponse RegisterWorkspaceDirectory(RegisterWorkspaceDirectoryRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RegisterWorkspaceDirectoryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RegisterWorkspaceDirectoryResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the RegisterWorkspaceDirectory operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the RegisterWorkspaceDirectory operation on AmazonWorkSpacesClient.
        /// 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 EndRegisterWorkspaceDirectory
        ///         operation.
        /// REST API Reference for RegisterWorkspaceDirectory Operation
        public virtual IAsyncResult BeginRegisterWorkspaceDirectory(RegisterWorkspaceDirectoryRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RegisterWorkspaceDirectoryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RegisterWorkspaceDirectoryResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  RegisterWorkspaceDirectory operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginRegisterWorkspaceDirectory.
        /// 
        /// Returns a  RegisterWorkspaceDirectoryResult from WorkSpaces.
        /// REST API Reference for RegisterWorkspaceDirectory Operation
        public virtual RegisterWorkspaceDirectoryResponse EndRegisterWorkspaceDirectory(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  RestoreWorkspace
        /// 
        /// Restores the specified WorkSpace to its last known healthy state.
        /// 
        ///  
        /// 
        /// You cannot restore a WorkSpace unless its state is  AVAILABLE, ERROR,
        /// UNHEALTHY, or STOPPED.
        /// 
        ///  
        /// 
        /// Restoring a WorkSpace is a potentially destructive action that can result in the loss
        /// of data. For more information, see Restore
        /// a WorkSpace.
        /// 
        ///  
        /// 
        /// This operation is asynchronous and returns before the WorkSpace is completely restored.
        /// 
        /// 
        /// Container for the necessary parameters to execute the RestoreWorkspace service method.
        /// 
        /// The response from the RestoreWorkspace service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// This operation is not supported.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for RestoreWorkspace Operation
        public virtual RestoreWorkspaceResponse RestoreWorkspace(RestoreWorkspaceRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RestoreWorkspaceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RestoreWorkspaceResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the RestoreWorkspace operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the RestoreWorkspace operation on AmazonWorkSpacesClient.
        /// 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 EndRestoreWorkspace
        ///         operation.
        /// REST API Reference for RestoreWorkspace Operation
        public virtual IAsyncResult BeginRestoreWorkspace(RestoreWorkspaceRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RestoreWorkspaceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RestoreWorkspaceResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  RestoreWorkspace operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginRestoreWorkspace.
        /// 
        /// Returns a  RestoreWorkspaceResult from WorkSpaces.
        /// REST API Reference for RestoreWorkspace Operation
        public virtual RestoreWorkspaceResponse EndRestoreWorkspace(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  RevokeIpRules
        /// 
        /// Removes one or more rules from the specified IP access control group.
        /// 
        /// Container for the necessary parameters to execute the RevokeIpRules service method.
        /// 
        /// The response from the RevokeIpRules service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The state of the resource is not valid for this operation.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for RevokeIpRules Operation
        public virtual RevokeIpRulesResponse RevokeIpRules(RevokeIpRulesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RevokeIpRulesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RevokeIpRulesResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the RevokeIpRules operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the RevokeIpRules operation on AmazonWorkSpacesClient.
        /// 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 EndRevokeIpRules
        ///         operation.
        /// REST API Reference for RevokeIpRules Operation
        public virtual IAsyncResult BeginRevokeIpRules(RevokeIpRulesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RevokeIpRulesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RevokeIpRulesResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  RevokeIpRules operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginRevokeIpRules.
        /// 
        /// Returns a  RevokeIpRulesResult from WorkSpaces.
        /// REST API Reference for RevokeIpRules Operation
        public virtual RevokeIpRulesResponse EndRevokeIpRules(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  StartWorkspaces
        /// 
        /// Starts the specified WorkSpaces.
        /// 
        ///  
        /// 
        /// You cannot start a WorkSpace unless it has a running mode of AutoStop
        /// and a state of STOPPED.
        /// 
        /// 
        /// Container for the necessary parameters to execute the StartWorkspaces service method.
        /// 
        /// The response from the StartWorkspaces service method, as returned by WorkSpaces.
        /// REST API Reference for StartWorkspaces Operation
        public virtual StartWorkspacesResponse StartWorkspaces(StartWorkspacesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = StartWorkspacesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = StartWorkspacesResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the StartWorkspaces operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the StartWorkspaces operation on AmazonWorkSpacesClient.
        /// 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 EndStartWorkspaces
        ///         operation.
        /// REST API Reference for StartWorkspaces Operation
        public virtual IAsyncResult BeginStartWorkspaces(StartWorkspacesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = StartWorkspacesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = StartWorkspacesResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  StartWorkspaces operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginStartWorkspaces.
        /// 
        /// Returns a  StartWorkspacesResult from WorkSpaces.
        /// REST API Reference for StartWorkspaces Operation
        public virtual StartWorkspacesResponse EndStartWorkspaces(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  StopWorkspaces
        /// 
        /// Stops the specified WorkSpaces.
        /// 
        ///  
        /// 
        /// You cannot stop a WorkSpace unless it has a running mode of AutoStop
        /// and a state of AVAILABLE, IMPAIRED, UNHEALTHY,
        /// or ERROR.
        /// 
        /// 
        /// Container for the necessary parameters to execute the StopWorkspaces service method.
        /// 
        /// The response from the StopWorkspaces service method, as returned by WorkSpaces.
        /// REST API Reference for StopWorkspaces Operation
        public virtual StopWorkspacesResponse StopWorkspaces(StopWorkspacesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = StopWorkspacesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = StopWorkspacesResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the StopWorkspaces operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the StopWorkspaces operation on AmazonWorkSpacesClient.
        /// 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 EndStopWorkspaces
        ///         operation.
        /// REST API Reference for StopWorkspaces Operation
        public virtual IAsyncResult BeginStopWorkspaces(StopWorkspacesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = StopWorkspacesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = StopWorkspacesResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  StopWorkspaces operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginStopWorkspaces.
        /// 
        /// Returns a  StopWorkspacesResult from WorkSpaces.
        /// REST API Reference for StopWorkspaces Operation
        public virtual StopWorkspacesResponse EndStopWorkspaces(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  TerminateWorkspaces
        /// 
        /// Terminates the specified WorkSpaces.
        /// 
        ///   
        /// 
        /// Terminating a WorkSpace is a permanent action and cannot be undone. The user's data
        /// is destroyed. If you need to archive any user data, contact Amazon Web Services Support
        /// before terminating the WorkSpace.
        /// 
        ///   
        /// 
        /// You can terminate a WorkSpace that is in any state except SUSPENDED.
        /// 
        ///  
        /// 
        /// This operation is asynchronous and returns before the WorkSpaces have been completely
        /// terminated. After a WorkSpace is terminated, the TERMINATED state is
        /// returned only briefly before the WorkSpace directory metadata is cleaned up, so this
        /// state is rarely returned. To confirm that a WorkSpace is terminated, check for the
        /// WorkSpace ID by using 
        /// DescribeWorkSpaces. If the WorkSpace ID isn't returned, then the WorkSpace has
        /// been successfully terminated.
        /// 
        ///   
        /// 
        /// Simple AD and AD Connector are made available to you free of charge to use with WorkSpaces.
        /// If there are no WorkSpaces being used with your Simple AD or AD Connector directory
        /// for 30 consecutive days, this directory will be automatically deregistered for use
        /// with Amazon WorkSpaces, and you will be charged for this directory as per the Directory
        /// Service pricing terms.
        /// 
        ///  
        /// 
        /// To delete empty directories, see 
        /// Delete the Directory for Your WorkSpaces. If you delete your Simple AD or AD Connector
        /// directory, you can always create a new one when you want to start using WorkSpaces
        /// again.
        /// 
        ///  
        /// 
        /// Container for the necessary parameters to execute the TerminateWorkspaces service method.
        /// 
        /// The response from the TerminateWorkspaces service method, as returned by WorkSpaces.
        /// REST API Reference for TerminateWorkspaces Operation
        public virtual TerminateWorkspacesResponse TerminateWorkspaces(TerminateWorkspacesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = TerminateWorkspacesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = TerminateWorkspacesResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the TerminateWorkspaces operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the TerminateWorkspaces operation on AmazonWorkSpacesClient.
        /// 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 EndTerminateWorkspaces
        ///         operation.
        /// REST API Reference for TerminateWorkspaces Operation
        public virtual IAsyncResult BeginTerminateWorkspaces(TerminateWorkspacesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = TerminateWorkspacesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = TerminateWorkspacesResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  TerminateWorkspaces operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginTerminateWorkspaces.
        /// 
        /// Returns a  TerminateWorkspacesResult from WorkSpaces.
        /// REST API Reference for TerminateWorkspaces Operation
        public virtual TerminateWorkspacesResponse EndTerminateWorkspaces(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  UpdateConnectClientAddIn
        /// 
        /// Updates a Amazon Connect client add-in. Use this action to update the name and endpoint
        /// URL of a Amazon Connect client add-in.
        /// 
        /// Container for the necessary parameters to execute the UpdateConnectClientAddIn service method.
        /// 
        /// The response from the UpdateConnectClientAddIn service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for UpdateConnectClientAddIn Operation
        public virtual UpdateConnectClientAddInResponse UpdateConnectClientAddIn(UpdateConnectClientAddInRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = UpdateConnectClientAddInRequestMarshaller.Instance;
            options.ResponseUnmarshaller = UpdateConnectClientAddInResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the UpdateConnectClientAddIn operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the UpdateConnectClientAddIn operation on AmazonWorkSpacesClient.
        /// 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 EndUpdateConnectClientAddIn
        ///         operation.
        /// REST API Reference for UpdateConnectClientAddIn Operation
        public virtual IAsyncResult BeginUpdateConnectClientAddIn(UpdateConnectClientAddInRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = UpdateConnectClientAddInRequestMarshaller.Instance;
            options.ResponseUnmarshaller = UpdateConnectClientAddInResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  UpdateConnectClientAddIn operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginUpdateConnectClientAddIn.
        /// 
        /// Returns a  UpdateConnectClientAddInResult from WorkSpaces.
        /// REST API Reference for UpdateConnectClientAddIn Operation
        public virtual UpdateConnectClientAddInResponse EndUpdateConnectClientAddIn(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  UpdateConnectionAliasPermission
        /// 
        /// Shares or unshares a connection alias with one account by specifying whether that
        /// account has permission to associate the connection alias with a directory. If the
        /// association permission is granted, the connection alias is shared with that account.
        /// If the association permission is revoked, the connection alias is unshared with the
        /// account. For more information, see 
        /// Cross-Region Redirection for Amazon WorkSpaces.
        /// 
        ///    -  
        /// 
        /// Before performing this operation, call 
        /// DescribeConnectionAliases to make sure that the current state of the connection
        /// alias is CREATED.
        /// 
        ///
-  
        /// 
        /// To delete a connection alias that has been shared, the shared account must first disassociate
        /// the connection alias from any directories it has been associated with. Then you must
        /// unshare the connection alias from the account it has been shared with. You can delete
        /// a connection alias only after it is no longer shared with any accounts or associated
        /// with any directories.
        /// 
        ///  
/// 
        /// Container for the necessary parameters to execute the UpdateConnectionAliasPermission service method.
        /// 
        /// The response from the UpdateConnectionAliasPermission service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The state of the resource is not valid for this operation.
        /// 
        /// 
        /// This operation is not supported.
        /// 
        /// 
        /// The resource is associated with a directory.
        /// 
        /// 
        /// Your resource limits have been exceeded.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for UpdateConnectionAliasPermission Operation
        public virtual UpdateConnectionAliasPermissionResponse UpdateConnectionAliasPermission(UpdateConnectionAliasPermissionRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = UpdateConnectionAliasPermissionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = UpdateConnectionAliasPermissionResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the UpdateConnectionAliasPermission operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the UpdateConnectionAliasPermission operation on AmazonWorkSpacesClient.
        /// 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 EndUpdateConnectionAliasPermission
        ///         operation.
        /// REST API Reference for UpdateConnectionAliasPermission Operation
        public virtual IAsyncResult BeginUpdateConnectionAliasPermission(UpdateConnectionAliasPermissionRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = UpdateConnectionAliasPermissionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = UpdateConnectionAliasPermissionResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  UpdateConnectionAliasPermission operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginUpdateConnectionAliasPermission.
        /// 
        /// Returns a  UpdateConnectionAliasPermissionResult from WorkSpaces.
        /// REST API Reference for UpdateConnectionAliasPermission Operation
        public virtual UpdateConnectionAliasPermissionResponse EndUpdateConnectionAliasPermission(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  UpdateRulesOfIpGroup
        /// 
        /// Replaces the current rules of the specified IP access control group with the specified
        /// rules.
        /// 
        /// Container for the necessary parameters to execute the UpdateRulesOfIpGroup service method.
        /// 
        /// The response from the UpdateRulesOfIpGroup service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// The state of the resource is not valid for this operation.
        /// 
        /// 
        /// Your resource limits have been exceeded.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// REST API Reference for UpdateRulesOfIpGroup Operation
        public virtual UpdateRulesOfIpGroupResponse UpdateRulesOfIpGroup(UpdateRulesOfIpGroupRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = UpdateRulesOfIpGroupRequestMarshaller.Instance;
            options.ResponseUnmarshaller = UpdateRulesOfIpGroupResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the UpdateRulesOfIpGroup operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the UpdateRulesOfIpGroup operation on AmazonWorkSpacesClient.
        /// 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 EndUpdateRulesOfIpGroup
        ///         operation.
        /// REST API Reference for UpdateRulesOfIpGroup Operation
        public virtual IAsyncResult BeginUpdateRulesOfIpGroup(UpdateRulesOfIpGroupRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = UpdateRulesOfIpGroupRequestMarshaller.Instance;
            options.ResponseUnmarshaller = UpdateRulesOfIpGroupResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  UpdateRulesOfIpGroup operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginUpdateRulesOfIpGroup.
        /// 
        /// Returns a  UpdateRulesOfIpGroupResult from WorkSpaces.
        /// REST API Reference for UpdateRulesOfIpGroup Operation
        public virtual UpdateRulesOfIpGroupResponse EndUpdateRulesOfIpGroup(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  UpdateWorkspaceBundle
        /// 
        /// Updates a WorkSpace bundle with a new image. For more information about updating WorkSpace
        /// bundles, see 
        /// Update a Custom WorkSpaces Bundle.
        /// 
        ///   
        /// 
        /// Existing WorkSpaces aren't automatically updated when you update the bundle that they're
        /// based on. To update existing WorkSpaces that are based on a bundle that you've updated,
        /// you must either rebuild the WorkSpaces or delete and recreate them.
        /// 
        ///  
        /// 
        /// Container for the necessary parameters to execute the UpdateWorkspaceBundle service method.
        /// 
        /// The response from the UpdateWorkspaceBundle service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// This operation is not supported.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// 
        /// The specified resource is not available.
        /// 
        /// REST API Reference for UpdateWorkspaceBundle Operation
        public virtual UpdateWorkspaceBundleResponse UpdateWorkspaceBundle(UpdateWorkspaceBundleRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = UpdateWorkspaceBundleRequestMarshaller.Instance;
            options.ResponseUnmarshaller = UpdateWorkspaceBundleResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the UpdateWorkspaceBundle operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the UpdateWorkspaceBundle operation on AmazonWorkSpacesClient.
        /// 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 EndUpdateWorkspaceBundle
        ///         operation.
        /// REST API Reference for UpdateWorkspaceBundle Operation
        public virtual IAsyncResult BeginUpdateWorkspaceBundle(UpdateWorkspaceBundleRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = UpdateWorkspaceBundleRequestMarshaller.Instance;
            options.ResponseUnmarshaller = UpdateWorkspaceBundleResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  UpdateWorkspaceBundle operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginUpdateWorkspaceBundle.
        /// 
        /// Returns a  UpdateWorkspaceBundleResult from WorkSpaces.
        /// REST API Reference for UpdateWorkspaceBundle Operation
        public virtual UpdateWorkspaceBundleResponse EndUpdateWorkspaceBundle(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
        #region  UpdateWorkspaceImagePermission
        /// 
        /// Shares or unshares an image with one account in the same Amazon Web Services Region
        /// by specifying whether that account has permission to copy the image. If the copy image
        /// permission is granted, the image is shared with that account. If the copy image permission
        /// is revoked, the image is unshared with the account.
        /// 
        ///  
        /// 
        /// After an image has been shared, the recipient account can copy the image to other
        /// Regions as needed.
        /// 
        ///  
        /// 
        /// In the China (Ningxia) Region, you can copy images only within the same Region.
        /// 
        ///  
        /// 
        /// In Amazon Web Services GovCloud (US), to copy images to and from other Regions, contact
        /// Amazon Web Services Support.
        /// 
        ///  
        /// 
        /// For more information about sharing images, see 
        /// Share or Unshare a Custom WorkSpaces Image.
        /// 
        /// -  
        /// 
        /// To delete an image that has been shared, you must unshare the image before you delete
        /// it.
        /// 
        ///  
-  
        /// 
        /// Sharing Bring Your Own License (BYOL) images across Amazon Web Services accounts isn't
        /// supported at this time in Amazon Web Services GovCloud (US). To share BYOL images
        /// across accounts in Amazon Web Services GovCloud (US), contact Amazon Web Services
        /// Support.
        /// 
        ///  
/// 
        /// Container for the necessary parameters to execute the UpdateWorkspaceImagePermission service method.
        /// 
        /// The response from the UpdateWorkspaceImagePermission service method, as returned by WorkSpaces.
        /// 
        /// The user is not authorized to access a resource.
        /// 
        /// 
        /// One or more parameter values are not valid.
        /// 
        /// 
        /// This operation is not supported.
        /// 
        /// 
        /// The resource could not be found.
        /// 
        /// 
        /// The specified resource is not available.
        /// 
        /// REST API Reference for UpdateWorkspaceImagePermission Operation
        public virtual UpdateWorkspaceImagePermissionResponse UpdateWorkspaceImagePermission(UpdateWorkspaceImagePermissionRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = UpdateWorkspaceImagePermissionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = UpdateWorkspaceImagePermissionResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Initiates the asynchronous execution of the UpdateWorkspaceImagePermission operation.
        /// 
        /// 
        /// Container for the necessary parameters to execute the UpdateWorkspaceImagePermission operation on AmazonWorkSpacesClient.
        /// 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 EndUpdateWorkspaceImagePermission
        ///         operation.
        /// REST API Reference for UpdateWorkspaceImagePermission Operation
        public virtual IAsyncResult BeginUpdateWorkspaceImagePermission(UpdateWorkspaceImagePermissionRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = UpdateWorkspaceImagePermissionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = UpdateWorkspaceImagePermissionResponseUnmarshaller.Instance;
            return BeginInvoke(request, options, callback, state);
        }
        /// 
        /// Finishes the asynchronous execution of the  UpdateWorkspaceImagePermission operation.
        /// 
        /// 
        /// The IAsyncResult returned by the call to BeginUpdateWorkspaceImagePermission.
        /// 
        /// Returns a  UpdateWorkspaceImagePermissionResult from WorkSpaces.
        /// REST API Reference for UpdateWorkspaceImagePermission Operation
        public virtual UpdateWorkspaceImagePermissionResponse EndUpdateWorkspaceImagePermission(IAsyncResult asyncResult)
        {
            return EndInvoke(asyncResult);
        }
        #endregion
        
    }
}