/*
 * 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 fms-2018-01-01.normal.json service model.
 */
using System;
using System.Runtime.ExceptionServices;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Net;
using Amazon.FMS.Model;
using Amazon.FMS.Model.Internal.MarshallTransformations;
using Amazon.FMS.Internal;
using Amazon.Runtime;
using Amazon.Runtime.Internal;
using Amazon.Runtime.Internal.Auth;
using Amazon.Runtime.Internal.Transform;
namespace Amazon.FMS
{
    /// 
    /// Implementation for accessing FMS
    ///
    /// This is the Firewall Manager API Reference. This guide is for developers who
    /// need detailed information about the Firewall Manager API actions, data types, and
    /// errors. For detailed information about Firewall Manager features, see the Firewall
    /// Manager Developer Guide.
    /// 
    ///  
    /// 
    /// Some API actions require explicit resource permissions. For information, see the developer
    /// guide topic Service
    /// roles for Firewall Manager. 
    /// 
    /// 
    public partial class AmazonFMSClient : AmazonServiceClient, IAmazonFMS
    {
        private static IServiceMetadata serviceMetadata = new AmazonFMSMetadata();
        
        #region Constructors
        /// 
        /// Constructs AmazonFMSClient 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 AmazonFMSClient()
            : base(FallbackCredentialsFactory.GetCredentials(), new AmazonFMSConfig()) { }
        /// 
        /// Constructs AmazonFMSClient 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 AmazonFMSClient(RegionEndpoint region)
            : base(FallbackCredentialsFactory.GetCredentials(), new AmazonFMSConfig{RegionEndpoint = region}) { }
        /// 
        /// Constructs AmazonFMSClient 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 AmazonFMSClient Configuration Object
        public AmazonFMSClient(AmazonFMSConfig config)
            : base(FallbackCredentialsFactory.GetCredentials(config), config){}
        /// 
        /// Constructs AmazonFMSClient with AWS Credentials
        /// 
        /// AWS Credentials
        public AmazonFMSClient(AWSCredentials credentials)
            : this(credentials, new AmazonFMSConfig())
        {
        }
        /// 
        /// Constructs AmazonFMSClient with AWS Credentials
        /// 
        /// AWS Credentials
        /// The region to connect.
        public AmazonFMSClient(AWSCredentials credentials, RegionEndpoint region)
            : this(credentials, new AmazonFMSConfig{RegionEndpoint = region})
        {
        }
        /// 
        /// Constructs AmazonFMSClient with AWS Credentials and an
        /// AmazonFMSClient Configuration object.
        /// 
        /// AWS Credentials
        /// The AmazonFMSClient Configuration Object
        public AmazonFMSClient(AWSCredentials credentials, AmazonFMSConfig clientConfig)
            : base(credentials, clientConfig)
        {
        }
        /// 
        /// Constructs AmazonFMSClient with AWS Access Key ID and AWS Secret Key
        /// 
        /// AWS Access Key ID
        /// AWS Secret Access Key
        public AmazonFMSClient(string awsAccessKeyId, string awsSecretAccessKey)
            : this(awsAccessKeyId, awsSecretAccessKey, new AmazonFMSConfig())
        {
        }
        /// 
        /// Constructs AmazonFMSClient with AWS Access Key ID and AWS Secret Key
        /// 
        /// AWS Access Key ID
        /// AWS Secret Access Key
        /// The region to connect.
        public AmazonFMSClient(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region)
            : this(awsAccessKeyId, awsSecretAccessKey, new AmazonFMSConfig() {RegionEndpoint=region})
        {
        }
        /// 
        /// Constructs AmazonFMSClient with AWS Access Key ID, AWS Secret Key and an
        /// AmazonFMSClient Configuration object. 
        /// 
        /// AWS Access Key ID
        /// AWS Secret Access Key
        /// The AmazonFMSClient Configuration Object
        public AmazonFMSClient(string awsAccessKeyId, string awsSecretAccessKey, AmazonFMSConfig clientConfig)
            : base(awsAccessKeyId, awsSecretAccessKey, clientConfig)
        {
        }
        /// 
        /// Constructs AmazonFMSClient with AWS Access Key ID and AWS Secret Key
        /// 
        /// AWS Access Key ID
        /// AWS Secret Access Key
        /// AWS Session Token
        public AmazonFMSClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken)
            : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonFMSConfig())
        {
        }
        /// 
        /// Constructs AmazonFMSClient 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 AmazonFMSClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region)
            : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonFMSConfig{RegionEndpoint = region})
        {
        }
        /// 
        /// Constructs AmazonFMSClient with AWS Access Key ID, AWS Secret Key and an
        /// AmazonFMSClient Configuration object. 
        /// 
        /// AWS Access Key ID
        /// AWS Secret Access Key
        /// AWS Session Token
        /// The AmazonFMSClient Configuration Object
        public AmazonFMSClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonFMSConfig clientConfig)
            : base(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, clientConfig)
        {
        }
        #endregion
#if AWS_ASYNC_ENUMERABLES_API
        private IFMSPaginatorFactory _paginators;
        /// 
        /// Paginators for the service
        /// 
        public IFMSPaginatorFactory Paginators 
        {
            get 
            {
                if (this._paginators == null) 
                {
                    this._paginators = new FMSPaginatorFactory(this);
                }
                return this._paginators;
            }
        }
#endif
        #region Overrides
        /// 
        /// Creates the signer for the service.
        /// 
        protected override AbstractAWSSigner CreateSigner()
        {
            return new AWS4Signer();
        } 
        /// 
        /// Customizes the runtime pipeline.
        /// 
        /// Runtime pipeline for the current client.
        protected override void CustomizeRuntimePipeline(RuntimePipeline pipeline)
        {
            pipeline.RemoveHandler();
            pipeline.AddHandlerAfter(new AmazonFMSEndpointResolver());
        }
        /// 
        /// 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  AssociateAdminAccount
        internal virtual AssociateAdminAccountResponse AssociateAdminAccount(AssociateAdminAccountRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateAdminAccountRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateAdminAccountResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Sets a Firewall Manager default administrator account. The Firewall Manager default
        /// administrator account can manage third-party firewalls and has full administrative
        /// scope that allows administration of all policy types, accounts, organizational units,
        /// and Regions. This account must be a member account of the organization in Organizations
        /// whose resources you want to protect.
        /// 
        ///  
        /// 
        /// For information about working with Firewall Manager administrator accounts, see Managing
        /// Firewall Manager administrators in the Firewall Manager Developer Guide.
        /// 
        /// 
        /// Container for the necessary parameters to execute the AssociateAdminAccount service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the AssociateAdminAccount service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The parameters of the request were invalid.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The operation exceeds a resource limit, for example, the maximum number of policy
        /// objects that you can create for an Amazon Web Services account. For more information,
        /// see Firewall
        /// Manager Limits in the WAF Developer Guide.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for AssociateAdminAccount Operation
        public virtual Task AssociateAdminAccountAsync(AssociateAdminAccountRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateAdminAccountRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateAdminAccountResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  AssociateThirdPartyFirewall
        internal virtual AssociateThirdPartyFirewallResponse AssociateThirdPartyFirewall(AssociateThirdPartyFirewallRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateThirdPartyFirewallRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateThirdPartyFirewallResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Sets the Firewall Manager policy administrator as a tenant administrator of a third-party
        /// firewall service. A tenant is an instance of the third-party firewall service that's
        /// associated with your Amazon Web Services customer account.
        /// 
        /// Container for the necessary parameters to execute the AssociateThirdPartyFirewall service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the AssociateThirdPartyFirewall service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The parameters of the request were invalid.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for AssociateThirdPartyFirewall Operation
        public virtual Task AssociateThirdPartyFirewallAsync(AssociateThirdPartyFirewallRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateThirdPartyFirewallRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateThirdPartyFirewallResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  BatchAssociateResource
        internal virtual BatchAssociateResourceResponse BatchAssociateResource(BatchAssociateResourceRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = BatchAssociateResourceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = BatchAssociateResourceResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Associate resources to a Firewall Manager resource set.
        /// 
        /// Container for the necessary parameters to execute the BatchAssociateResource service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the BatchAssociateResource service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The parameters of the request were invalid.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The operation exceeds a resource limit, for example, the maximum number of policy
        /// objects that you can create for an Amazon Web Services account. For more information,
        /// see Firewall
        /// Manager Limits in the WAF Developer Guide.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for BatchAssociateResource Operation
        public virtual Task BatchAssociateResourceAsync(BatchAssociateResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = BatchAssociateResourceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = BatchAssociateResourceResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  BatchDisassociateResource
        internal virtual BatchDisassociateResourceResponse BatchDisassociateResource(BatchDisassociateResourceRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = BatchDisassociateResourceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = BatchDisassociateResourceResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Disassociates resources from a Firewall Manager resource set.
        /// 
        /// Container for the necessary parameters to execute the BatchDisassociateResource service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the BatchDisassociateResource service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The parameters of the request were invalid.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for BatchDisassociateResource Operation
        public virtual Task BatchDisassociateResourceAsync(BatchDisassociateResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = BatchDisassociateResourceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = BatchDisassociateResourceResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  DeleteAppsList
        internal virtual DeleteAppsListResponse DeleteAppsList(DeleteAppsListRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteAppsListRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteAppsListResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Permanently deletes an Firewall Manager applications list.
        /// 
        /// Container for the necessary parameters to execute the DeleteAppsList service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the DeleteAppsList service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for DeleteAppsList Operation
        public virtual Task DeleteAppsListAsync(DeleteAppsListRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteAppsListRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteAppsListResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  DeleteNotificationChannel
        internal virtual DeleteNotificationChannelResponse DeleteNotificationChannel(DeleteNotificationChannelRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteNotificationChannelRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteNotificationChannelResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Deletes an Firewall Manager association with the IAM role and the Amazon Simple Notification
        /// Service (SNS) topic that is used to record Firewall Manager SNS logs.
        /// 
        /// Container for the necessary parameters to execute the DeleteNotificationChannel service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the DeleteNotificationChannel service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for DeleteNotificationChannel Operation
        public virtual Task DeleteNotificationChannelAsync(DeleteNotificationChannelRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteNotificationChannelRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteNotificationChannelResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  DeletePolicy
        internal virtual DeletePolicyResponse DeletePolicy(DeletePolicyRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeletePolicyRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeletePolicyResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Permanently deletes an Firewall Manager policy.
        /// 
        /// Container for the necessary parameters to execute the DeletePolicy service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the DeletePolicy service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The parameters of the request were invalid.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The operation exceeds a resource limit, for example, the maximum number of policy
        /// objects that you can create for an Amazon Web Services account. For more information,
        /// see Firewall
        /// Manager Limits in the WAF Developer Guide.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for DeletePolicy Operation
        public virtual Task DeletePolicyAsync(DeletePolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeletePolicyRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeletePolicyResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  DeleteProtocolsList
        internal virtual DeleteProtocolsListResponse DeleteProtocolsList(DeleteProtocolsListRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteProtocolsListRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteProtocolsListResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Permanently deletes an Firewall Manager protocols list.
        /// 
        /// Container for the necessary parameters to execute the DeleteProtocolsList service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the DeleteProtocolsList service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for DeleteProtocolsList Operation
        public virtual Task DeleteProtocolsListAsync(DeleteProtocolsListRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteProtocolsListRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteProtocolsListResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  DeleteResourceSet
        internal virtual DeleteResourceSetResponse DeleteResourceSet(DeleteResourceSetRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteResourceSetRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteResourceSetResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Deletes the specified ResourceSet.
        /// 
        /// Container for the necessary parameters to execute the DeleteResourceSet service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the DeleteResourceSet service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The parameters of the request were invalid.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for DeleteResourceSet Operation
        public virtual Task DeleteResourceSetAsync(DeleteResourceSetRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteResourceSetRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteResourceSetResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  DisassociateAdminAccount
        internal virtual DisassociateAdminAccountResponse DisassociateAdminAccount(DisassociateAdminAccountRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateAdminAccountRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateAdminAccountResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Disassociates an Firewall Manager administrator account. To set a different account
        /// as an Firewall Manager administrator, submit a PutAdminAccount request. To
        /// set an account as a default administrator account, you must submit an AssociateAdminAccount
        /// request.
        /// 
        ///  
        /// 
        /// Disassociation of the default administrator account follows the first in, last out
        /// principle. If you are the default administrator, all Firewall Manager administrators
        /// within the organization must first disassociate their accounts before you can disassociate
        /// your account.
        /// 
        /// 
        /// Container for the necessary parameters to execute the DisassociateAdminAccount service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the DisassociateAdminAccount service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for DisassociateAdminAccount Operation
        public virtual Task DisassociateAdminAccountAsync(DisassociateAdminAccountRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateAdminAccountRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateAdminAccountResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  DisassociateThirdPartyFirewall
        internal virtual DisassociateThirdPartyFirewallResponse DisassociateThirdPartyFirewall(DisassociateThirdPartyFirewallRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateThirdPartyFirewallRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateThirdPartyFirewallResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Disassociates a Firewall Manager policy administrator from a third-party firewall
        /// tenant. When you call DisassociateThirdPartyFirewall, the third-party
        /// firewall vendor deletes all of the firewalls that are associated with the account.
        /// 
        /// Container for the necessary parameters to execute the DisassociateThirdPartyFirewall service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the DisassociateThirdPartyFirewall service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The parameters of the request were invalid.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for DisassociateThirdPartyFirewall Operation
        public virtual Task DisassociateThirdPartyFirewallAsync(DisassociateThirdPartyFirewallRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateThirdPartyFirewallRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateThirdPartyFirewallResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  GetAdminAccount
        internal virtual GetAdminAccountResponse GetAdminAccount(GetAdminAccountRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetAdminAccountRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetAdminAccountResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Returns the Organizations account that is associated with Firewall Manager as the
        /// Firewall Manager default administrator.
        /// 
        /// Container for the necessary parameters to execute the GetAdminAccount service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the GetAdminAccount service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for GetAdminAccount Operation
        public virtual Task GetAdminAccountAsync(GetAdminAccountRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetAdminAccountRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetAdminAccountResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  GetAdminScope
        internal virtual GetAdminScopeResponse GetAdminScope(GetAdminScopeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetAdminScopeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetAdminScopeResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Returns information about the specified account's administrative scope. The admistrative
        /// scope defines the resources that an Firewall Manager administrator can manage.
        /// 
        /// Container for the necessary parameters to execute the GetAdminScope service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the GetAdminScope service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The parameters of the request were invalid.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The operation exceeds a resource limit, for example, the maximum number of policy
        /// objects that you can create for an Amazon Web Services account. For more information,
        /// see Firewall
        /// Manager Limits in the WAF Developer Guide.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for GetAdminScope Operation
        public virtual Task GetAdminScopeAsync(GetAdminScopeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetAdminScopeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetAdminScopeResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  GetAppsList
        internal virtual GetAppsListResponse GetAppsList(GetAppsListRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetAppsListRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetAppsListResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Returns information about the specified Firewall Manager applications list.
        /// 
        /// Container for the necessary parameters to execute the GetAppsList service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the GetAppsList service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for GetAppsList Operation
        public virtual Task GetAppsListAsync(GetAppsListRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetAppsListRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetAppsListResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  GetComplianceDetail
        internal virtual GetComplianceDetailResponse GetComplianceDetail(GetComplianceDetailRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetComplianceDetailRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetComplianceDetailResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Returns detailed compliance information about the specified member account. Details
        /// include resources that are in and out of compliance with the specified policy. 
        /// 
        ///   -  
        /// 
        /// Resources are considered noncompliant for WAF and Shield Advanced policies if the
        /// specified policy has not been applied to them.
        /// 
        ///  
  -  
        /// 
        /// Resources are considered noncompliant for security group policies if they are in scope
        /// of the policy, they violate one or more of the policy rules, and remediation is disabled
        /// or not possible.
        /// 
        ///  
  -  
        /// 
        /// Resources are considered noncompliant for Network Firewall policies if a firewall
        /// is missing in the VPC, if the firewall endpoint isn't set up in an expected Availability
        /// Zone and subnet, if a subnet created by the Firewall Manager doesn't have the expected
        /// route table, and for modifications to a firewall policy that violate the Firewall
        /// Manager policy's rules.
        /// 
        ///  
  -  
        /// 
        /// Resources are considered noncompliant for DNS Firewall policies if a DNS Firewall
        /// rule group is missing from the rule group associations for the VPC. 
        /// 
        ///  
  
        /// 
        /// Container for the necessary parameters to execute the GetComplianceDetail service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the GetComplianceDetail service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The parameters of the request were invalid.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for GetComplianceDetail Operation
        public virtual Task GetComplianceDetailAsync(GetComplianceDetailRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetComplianceDetailRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetComplianceDetailResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  GetNotificationChannel
        internal virtual GetNotificationChannelResponse GetNotificationChannel(GetNotificationChannelRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetNotificationChannelRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetNotificationChannelResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Information about the Amazon Simple Notification Service (SNS) topic that is used
        /// to record Firewall Manager SNS logs.
        /// 
        /// Container for the necessary parameters to execute the GetNotificationChannel service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the GetNotificationChannel service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for GetNotificationChannel Operation
        public virtual Task GetNotificationChannelAsync(GetNotificationChannelRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetNotificationChannelRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetNotificationChannelResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  GetPolicy
        internal virtual GetPolicyResponse GetPolicy(GetPolicyRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetPolicyRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetPolicyResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Returns information about the specified Firewall Manager policy.
        /// 
        /// Container for the necessary parameters to execute the GetPolicy service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the GetPolicy service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The value of the Type parameter is invalid.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for GetPolicy Operation
        public virtual Task GetPolicyAsync(GetPolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetPolicyRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetPolicyResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  GetProtectionStatus
        internal virtual GetProtectionStatusResponse GetProtectionStatus(GetProtectionStatusRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetProtectionStatusRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetProtectionStatusResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// If you created a Shield Advanced policy, returns policy-level attack summary information
        /// in the event of a potential DDoS attack. Other policy types are currently unsupported.
        /// 
        /// Container for the necessary parameters to execute the GetProtectionStatus service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the GetProtectionStatus service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The parameters of the request were invalid.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for GetProtectionStatus Operation
        public virtual Task GetProtectionStatusAsync(GetProtectionStatusRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetProtectionStatusRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetProtectionStatusResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  GetProtocolsList
        internal virtual GetProtocolsListResponse GetProtocolsList(GetProtocolsListRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetProtocolsListRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetProtocolsListResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Returns information about the specified Firewall Manager protocols list.
        /// 
        /// Container for the necessary parameters to execute the GetProtocolsList service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the GetProtocolsList service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for GetProtocolsList Operation
        public virtual Task GetProtocolsListAsync(GetProtocolsListRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetProtocolsListRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetProtocolsListResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  GetResourceSet
        internal virtual GetResourceSetResponse GetResourceSet(GetResourceSetRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetResourceSetRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetResourceSetResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Gets information about a specific resource set.
        /// 
        /// Container for the necessary parameters to execute the GetResourceSet service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the GetResourceSet service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The parameters of the request were invalid.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for GetResourceSet Operation
        public virtual Task GetResourceSetAsync(GetResourceSetRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetResourceSetRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetResourceSetResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  GetThirdPartyFirewallAssociationStatus
        internal virtual GetThirdPartyFirewallAssociationStatusResponse GetThirdPartyFirewallAssociationStatus(GetThirdPartyFirewallAssociationStatusRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetThirdPartyFirewallAssociationStatusRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetThirdPartyFirewallAssociationStatusResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// The onboarding status of a Firewall Manager admin account to third-party firewall
        /// vendor tenant.
        /// 
        /// Container for the necessary parameters to execute the GetThirdPartyFirewallAssociationStatus service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the GetThirdPartyFirewallAssociationStatus service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The parameters of the request were invalid.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for GetThirdPartyFirewallAssociationStatus Operation
        public virtual Task GetThirdPartyFirewallAssociationStatusAsync(GetThirdPartyFirewallAssociationStatusRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetThirdPartyFirewallAssociationStatusRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetThirdPartyFirewallAssociationStatusResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  GetViolationDetails
        internal virtual GetViolationDetailsResponse GetViolationDetails(GetViolationDetailsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetViolationDetailsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetViolationDetailsResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Retrieves violations for a resource based on the specified Firewall Manager policy
        /// and Amazon Web Services account.
        /// 
        /// Container for the necessary parameters to execute the GetViolationDetails service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the GetViolationDetails service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The parameters of the request were invalid.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for GetViolationDetails Operation
        public virtual Task GetViolationDetailsAsync(GetViolationDetailsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetViolationDetailsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetViolationDetailsResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  ListAdminAccountsForOrganization
        internal virtual ListAdminAccountsForOrganizationResponse ListAdminAccountsForOrganization(ListAdminAccountsForOrganizationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListAdminAccountsForOrganizationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListAdminAccountsForOrganizationResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Returns a AdminAccounts object that lists the Firewall Manager administrators
        /// within the organization that are onboarded to Firewall Manager by AssociateAdminAccount.
        /// 
        ///  
        /// 
        /// This operation can be called only from the organization's management account.
        /// 
        /// 
        /// Container for the necessary parameters to execute the ListAdminAccountsForOrganization service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the ListAdminAccountsForOrganization service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The operation exceeds a resource limit, for example, the maximum number of policy
        /// objects that you can create for an Amazon Web Services account. For more information,
        /// see Firewall
        /// Manager Limits in the WAF Developer Guide.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for ListAdminAccountsForOrganization Operation
        public virtual Task ListAdminAccountsForOrganizationAsync(ListAdminAccountsForOrganizationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListAdminAccountsForOrganizationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListAdminAccountsForOrganizationResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  ListAdminsManagingAccount
        internal virtual ListAdminsManagingAccountResponse ListAdminsManagingAccount(ListAdminsManagingAccountRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListAdminsManagingAccountRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListAdminsManagingAccountResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Lists the accounts that are managing the specified Organizations member account. This
        /// is useful for any member account so that they can view the accounts who are managing
        /// their account. This operation only returns the managing administrators that have the
        /// requested account within their AdminScope.
        /// 
        /// Container for the necessary parameters to execute the ListAdminsManagingAccount service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the ListAdminsManagingAccount service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The parameters of the request were invalid.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for ListAdminsManagingAccount Operation
        public virtual Task ListAdminsManagingAccountAsync(ListAdminsManagingAccountRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListAdminsManagingAccountRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListAdminsManagingAccountResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  ListAppsLists
        internal virtual ListAppsListsResponse ListAppsLists(ListAppsListsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListAppsListsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListAppsListsResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Returns an array of AppsListDataSummary objects.
        /// 
        /// Container for the necessary parameters to execute the ListAppsLists service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the ListAppsLists service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The operation exceeds a resource limit, for example, the maximum number of policy
        /// objects that you can create for an Amazon Web Services account. For more information,
        /// see Firewall
        /// Manager Limits in the WAF Developer Guide.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for ListAppsLists Operation
        public virtual Task ListAppsListsAsync(ListAppsListsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListAppsListsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListAppsListsResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  ListComplianceStatus
        internal virtual ListComplianceStatusResponse ListComplianceStatus(ListComplianceStatusRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListComplianceStatusRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListComplianceStatusResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Returns an array of PolicyComplianceStatus objects. Use PolicyComplianceStatus
        /// to get a summary of which member accounts are protected by the specified policy.
        /// 
        /// Container for the necessary parameters to execute the ListComplianceStatus service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the ListComplianceStatus service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for ListComplianceStatus Operation
        public virtual Task ListComplianceStatusAsync(ListComplianceStatusRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListComplianceStatusRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListComplianceStatusResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  ListDiscoveredResources
        internal virtual ListDiscoveredResourcesResponse ListDiscoveredResources(ListDiscoveredResourcesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListDiscoveredResourcesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListDiscoveredResourcesResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Returns an array of resources in the organization's accounts that are available to
        /// be associated with a resource set.
        /// 
        /// Container for the necessary parameters to execute the ListDiscoveredResources service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the ListDiscoveredResources service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The parameters of the request were invalid.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// REST API Reference for ListDiscoveredResources Operation
        public virtual Task ListDiscoveredResourcesAsync(ListDiscoveredResourcesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListDiscoveredResourcesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListDiscoveredResourcesResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  ListMemberAccounts
        internal virtual ListMemberAccountsResponse ListMemberAccounts(ListMemberAccountsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListMemberAccountsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListMemberAccountsResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Returns a MemberAccounts object that lists the member accounts in the
        /// administrator's Amazon Web Services organization.
        /// 
        ///  
        /// 
        /// Either an Firewall Manager administrator or the organization's management account
        /// can make this request.
        /// 
        /// 
        /// Container for the necessary parameters to execute the ListMemberAccounts service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the ListMemberAccounts service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for ListMemberAccounts Operation
        public virtual Task ListMemberAccountsAsync(ListMemberAccountsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListMemberAccountsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListMemberAccountsResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  ListPolicies
        internal virtual ListPoliciesResponse ListPolicies(ListPoliciesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListPoliciesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListPoliciesResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Returns an array of PolicySummary objects.
        /// 
        /// Container for the necessary parameters to execute the ListPolicies service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the ListPolicies service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The operation exceeds a resource limit, for example, the maximum number of policy
        /// objects that you can create for an Amazon Web Services account. For more information,
        /// see Firewall
        /// Manager Limits in the WAF Developer Guide.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for ListPolicies Operation
        public virtual Task ListPoliciesAsync(ListPoliciesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListPoliciesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListPoliciesResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  ListProtocolsLists
        internal virtual ListProtocolsListsResponse ListProtocolsLists(ListProtocolsListsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListProtocolsListsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListProtocolsListsResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Returns an array of ProtocolsListDataSummary objects.
        /// 
        /// Container for the necessary parameters to execute the ListProtocolsLists service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the ListProtocolsLists service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for ListProtocolsLists Operation
        public virtual Task ListProtocolsListsAsync(ListProtocolsListsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListProtocolsListsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListProtocolsListsResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  ListResourceSetResources
        internal virtual ListResourceSetResourcesResponse ListResourceSetResources(ListResourceSetResourcesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListResourceSetResourcesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListResourceSetResourcesResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Returns an array of resources that are currently associated to a resource set.
        /// 
        /// Container for the necessary parameters to execute the ListResourceSetResources service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the ListResourceSetResources service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The parameters of the request were invalid.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for ListResourceSetResources Operation
        public virtual Task ListResourceSetResourcesAsync(ListResourceSetResourcesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListResourceSetResourcesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListResourceSetResourcesResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  ListResourceSets
        internal virtual ListResourceSetsResponse ListResourceSets(ListResourceSetsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListResourceSetsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListResourceSetsResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Returns an array of ResourceSetSummary objects.
        /// 
        /// Container for the necessary parameters to execute the ListResourceSets service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the ListResourceSets service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The parameters of the request were invalid.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// REST API Reference for ListResourceSets Operation
        public virtual Task ListResourceSetsAsync(ListResourceSetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListResourceSetsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListResourceSetsResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  ListTagsForResource
        internal virtual ListTagsForResourceResponse ListTagsForResource(ListTagsForResourceRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Retrieves the list of tags for the specified Amazon Web Services resource.
        /// 
        /// Container for the necessary parameters to execute the ListTagsForResource service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the ListTagsForResource service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The parameters of the request were invalid.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for ListTagsForResource Operation
        public virtual Task ListTagsForResourceAsync(ListTagsForResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  ListThirdPartyFirewallFirewallPolicies
        internal virtual ListThirdPartyFirewallFirewallPoliciesResponse ListThirdPartyFirewallFirewallPolicies(ListThirdPartyFirewallFirewallPoliciesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListThirdPartyFirewallFirewallPoliciesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListThirdPartyFirewallFirewallPoliciesResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Retrieves a list of all of the third-party firewall policies that are associated with
        /// the third-party firewall administrator's account.
        /// 
        /// Container for the necessary parameters to execute the ListThirdPartyFirewallFirewallPolicies service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the ListThirdPartyFirewallFirewallPolicies service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The parameters of the request were invalid.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for ListThirdPartyFirewallFirewallPolicies Operation
        public virtual Task ListThirdPartyFirewallFirewallPoliciesAsync(ListThirdPartyFirewallFirewallPoliciesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListThirdPartyFirewallFirewallPoliciesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListThirdPartyFirewallFirewallPoliciesResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  PutAdminAccount
        internal virtual PutAdminAccountResponse PutAdminAccount(PutAdminAccountRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = PutAdminAccountRequestMarshaller.Instance;
            options.ResponseUnmarshaller = PutAdminAccountResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Creates or updates an Firewall Manager administrator account. The account must be
        /// a member of the organization that was onboarded to Firewall Manager by AssociateAdminAccount.
        /// Only the organization's management account can create an Firewall Manager administrator
        /// account. When you create an Firewall Manager administrator account, the service checks
        /// to see if the account is already a delegated administrator within Organizations. If
        /// the account isn't a delegated administrator, Firewall Manager calls Organizations
        /// to delegate the account within Organizations. For more information about administrator
        /// accounts within Organizations, see Managing
        /// the Amazon Web Services Accounts in Your Organization.
        /// 
        /// Container for the necessary parameters to execute the PutAdminAccount service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the PutAdminAccount service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The parameters of the request were invalid.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The operation exceeds a resource limit, for example, the maximum number of policy
        /// objects that you can create for an Amazon Web Services account. For more information,
        /// see Firewall
        /// Manager Limits in the WAF Developer Guide.
        /// 
        /// REST API Reference for PutAdminAccount Operation
        public virtual Task PutAdminAccountAsync(PutAdminAccountRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = PutAdminAccountRequestMarshaller.Instance;
            options.ResponseUnmarshaller = PutAdminAccountResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  PutAppsList
        internal virtual PutAppsListResponse PutAppsList(PutAppsListRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = PutAppsListRequestMarshaller.Instance;
            options.ResponseUnmarshaller = PutAppsListResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Creates an Firewall Manager applications list.
        /// 
        /// Container for the necessary parameters to execute the PutAppsList service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the PutAppsList service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The parameters of the request were invalid.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The operation exceeds a resource limit, for example, the maximum number of policy
        /// objects that you can create for an Amazon Web Services account. For more information,
        /// see Firewall
        /// Manager Limits in the WAF Developer Guide.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for PutAppsList Operation
        public virtual Task PutAppsListAsync(PutAppsListRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = PutAppsListRequestMarshaller.Instance;
            options.ResponseUnmarshaller = PutAppsListResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  PutNotificationChannel
        internal virtual PutNotificationChannelResponse PutNotificationChannel(PutNotificationChannelRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = PutNotificationChannelRequestMarshaller.Instance;
            options.ResponseUnmarshaller = PutNotificationChannelResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Designates the IAM role and Amazon Simple Notification Service (SNS) topic that Firewall
        /// Manager uses to record SNS logs.
        /// 
        ///  
        /// 
        /// To perform this action outside of the console, you must first configure the SNS topic's
        /// access policy to allow the SnsRoleName to publish SNS logs. If the SnsRoleName
        /// provided is a role other than the AWSServiceRoleForFMS service-linked
        /// role, this role must have a trust relationship configured to allow the Firewall Manager
        /// service principal fms.amazonaws.com to assume this role. For information
        /// about configuring an SNS access policy, see Service
        /// roles for Firewall Manager in the Firewall Manager Developer Guide.
        /// 
        /// 
        /// Container for the necessary parameters to execute the PutNotificationChannel service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the PutNotificationChannel service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for PutNotificationChannel Operation
        public virtual Task PutNotificationChannelAsync(PutNotificationChannelRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = PutNotificationChannelRequestMarshaller.Instance;
            options.ResponseUnmarshaller = PutNotificationChannelResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  PutPolicy
        internal virtual PutPolicyResponse PutPolicy(PutPolicyRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = PutPolicyRequestMarshaller.Instance;
            options.ResponseUnmarshaller = PutPolicyResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Creates an Firewall Manager policy.
        /// 
        ///  
        /// 
        /// Firewall Manager provides the following types of policies: 
        /// 
        ///   -  
        /// 
        /// An WAF policy (type WAFV2), which defines rule groups to run first in the corresponding
        /// WAF web ACL and rule groups to run last in the web ACL.
        /// 
        ///  
  -  
        /// 
        /// An WAF Classic policy (type WAF), which defines a rule group. 
        /// 
        ///  
  -  
        /// 
        /// A Shield Advanced policy, which applies Shield Advanced protection to specified accounts
        /// and resources.
        /// 
        ///  
  -  
        /// 
        /// A security group policy, which manages VPC security groups across your Amazon Web
        /// Services organization. 
        /// 
        ///  
  -  
        /// 
        /// An Network Firewall policy, which provides firewall rules to filter network traffic
        /// in specified Amazon VPCs.
        /// 
        ///  
  -  
        /// 
        /// A DNS Firewall policy, which provides RouteĀ 53 Resolver DNS Firewall rules to filter
        /// DNS queries for specified VPCs.
        /// 
        ///  
  
 
        /// 
        /// Each policy is specific to one of the types. If you want to enforce more than one
        /// policy type across accounts, create multiple policies. You can create multiple policies
        /// for each type.
        /// 
        ///  
        /// 
        /// You must be subscribed to Shield Advanced to create a Shield Advanced policy. For
        /// more information about subscribing to Shield Advanced, see CreateSubscription.
        /// 
        /// 
        /// Container for the necessary parameters to execute the PutPolicy service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the PutPolicy service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The parameters of the request were invalid.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The value of the Type parameter is invalid.
        /// 
        /// 
        /// The operation exceeds a resource limit, for example, the maximum number of policy
        /// objects that you can create for an Amazon Web Services account. For more information,
        /// see Firewall
        /// Manager Limits in the WAF Developer Guide.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for PutPolicy Operation
        public virtual Task PutPolicyAsync(PutPolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = PutPolicyRequestMarshaller.Instance;
            options.ResponseUnmarshaller = PutPolicyResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  PutProtocolsList
        internal virtual PutProtocolsListResponse PutProtocolsList(PutProtocolsListRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = PutProtocolsListRequestMarshaller.Instance;
            options.ResponseUnmarshaller = PutProtocolsListResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Creates an Firewall Manager protocols list.
        /// 
        /// Container for the necessary parameters to execute the PutProtocolsList service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the PutProtocolsList service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The parameters of the request were invalid.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The operation exceeds a resource limit, for example, the maximum number of policy
        /// objects that you can create for an Amazon Web Services account. For more information,
        /// see Firewall
        /// Manager Limits in the WAF Developer Guide.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for PutProtocolsList Operation
        public virtual Task PutProtocolsListAsync(PutProtocolsListRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = PutProtocolsListRequestMarshaller.Instance;
            options.ResponseUnmarshaller = PutProtocolsListResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  PutResourceSet
        internal virtual PutResourceSetResponse PutResourceSet(PutResourceSetRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = PutResourceSetRequestMarshaller.Instance;
            options.ResponseUnmarshaller = PutResourceSetResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Creates the resource set.
        /// 
        ///  
        /// 
        /// An Firewall Manager resource set defines the resources to import into an Firewall
        /// Manager policy from another Amazon Web Services service.
        /// 
        /// 
        /// Container for the necessary parameters to execute the PutResourceSet service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the PutResourceSet service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The parameters of the request were invalid.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The operation exceeds a resource limit, for example, the maximum number of policy
        /// objects that you can create for an Amazon Web Services account. For more information,
        /// see Firewall
        /// Manager Limits in the WAF Developer Guide.
        /// 
        /// REST API Reference for PutResourceSet Operation
        public virtual Task PutResourceSetAsync(PutResourceSetRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = PutResourceSetRequestMarshaller.Instance;
            options.ResponseUnmarshaller = PutResourceSetResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  TagResource
        internal virtual TagResourceResponse TagResource(TagResourceRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = TagResourceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Adds one or more tags to an Amazon Web Services resource.
        /// 
        /// Container for the necessary parameters to execute the TagResource service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the TagResource service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The parameters of the request were invalid.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The operation exceeds a resource limit, for example, the maximum number of policy
        /// objects that you can create for an Amazon Web Services account. For more information,
        /// see Firewall
        /// Manager Limits in the WAF Developer Guide.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for TagResource Operation
        public virtual Task TagResourceAsync(TagResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = TagResourceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
        #region  UntagResource
        internal virtual UntagResourceResponse UntagResource(UntagResourceRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = UntagResourceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance;
            return Invoke(request, options);
        }
        /// 
        /// Removes one or more tags from an Amazon Web Services resource.
        /// 
        /// Container for the necessary parameters to execute the UntagResource service method.
        /// 
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// 
        /// 
        /// The response from the UntagResource service method, as returned by FMS.
        /// 
        /// The operation failed because of a system problem, even though the request was valid.
        /// Retry your request.
        /// 
        /// 
        /// The parameters of the request were invalid.
        /// 
        /// 
        /// The operation failed because there was nothing to do or the operation wasn't possible.
        /// For example, you might have submitted an AssociateAdminAccount request
        /// for an account ID that was already set as the Firewall Manager administrator. Or you
        /// might have tried to access a Region that's disabled by default, and that you need
        /// to enable for the Firewall Manager administrator account and for Organizations before
        /// you can access it.
        /// 
        /// 
        /// The specified resource was not found.
        /// 
        /// REST API Reference for UntagResource Operation
        public virtual Task UntagResourceAsync(UntagResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = UntagResourceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance;
            return InvokeAsync(request, options, cancellationToken);
        }
        #endregion
        
    }
}