text:
/*
 * Do not modify this file. This file is generated from the email-2010-12-01.normal.json service model.
 */

using System;
using System.Runtime.ExceptionServices;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;

using Amazon.SimpleEmail.Model;
using Amazon.SimpleEmail.Model.Internal.MarshallTransformations;
using Amazon.Runtime;
using Amazon.Runtime.Internal;
using Amazon.Runtime.Internal.Auth;
using Amazon.Runtime.Internal.Transform;

namespace Amazon.SimpleEmail
{
    ///
    /// Implementation for accessing SimpleEmailService
    ///
    /// Amazon Simple Email Service
    /// <para>
    ///  This is the API Reference for Amazon Simple Email Service (Amazon SES). This documentation
    /// is intended to be used in conjunction with the Amazon
    /// SES Developer Guide.
    /// </para>
    ///  <note>For a list of Amazon SES endpoints to use in service requests, see Regions
    /// and Amazon SES in the Amazon SES Developer Guide. </note>
    ///
    public partial class AmazonSimpleEmailServiceClient : AmazonServiceClient, IAmazonSimpleEmailService
    {
        #region Constructors

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

        ///
        /// Constructs AmazonSimpleEmailServiceClient 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>
        ///
        ///
        ///
        /// <param name="region">The region to connect.</param>
        public AmazonSimpleEmailServiceClient(RegionEndpoint region)
            : base(FallbackCredentialsFactory.GetCredentials(), new AmazonSimpleEmailServiceConfig{RegionEndpoint = region}) { }

        ///
        /// Constructs AmazonSimpleEmailServiceClient 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>
        ///
        ///
        ///
        /// <param name="config">The AmazonSimpleEmailServiceClient Configuration Object</param>
        public AmazonSimpleEmailServiceClient(AmazonSimpleEmailServiceConfig config)
            : base(FallbackCredentialsFactory.GetCredentials(), config) { }

        ///
        /// Constructs AmazonSimpleEmailServiceClient with AWS Credentials
        ///
        /// <param name="credentials">AWS Credentials</param>
        public AmazonSimpleEmailServiceClient(AWSCredentials credentials)
            : this(credentials, new AmazonSimpleEmailServiceConfig())
        {
        }

        ///
        /// Constructs AmazonSimpleEmailServiceClient with AWS Credentials
        ///
        /// <param name="credentials">AWS Credentials</param>
        /// <param name="region">The region to connect.</param>
        public AmazonSimpleEmailServiceClient(AWSCredentials credentials, RegionEndpoint region)
            : this(credentials, new AmazonSimpleEmailServiceConfig{RegionEndpoint = region})
        {
        }

        ///
        /// Constructs AmazonSimpleEmailServiceClient with AWS Credentials and an
        /// AmazonSimpleEmailServiceClient Configuration object.
        ///
        /// <param name="credentials">AWS Credentials</param>
        /// <param name="clientConfig">The AmazonSimpleEmailServiceClient Configuration Object</param>
        public AmazonSimpleEmailServiceClient(AWSCredentials credentials, AmazonSimpleEmailServiceConfig clientConfig)
            : base(credentials, clientConfig)
        {
        }

        ///
        /// Constructs AmazonSimpleEmailServiceClient with AWS Access Key ID and AWS Secret Key
        ///
        /// <param name="awsAccessKeyId">AWS Access Key ID</param>
        /// <param name="awsSecretAccessKey">AWS Secret Access Key</param>
        public AmazonSimpleEmailServiceClient(string awsAccessKeyId, string awsSecretAccessKey)
            : this(awsAccessKeyId, awsSecretAccessKey, new AmazonSimpleEmailServiceConfig())
        {
        }

        ///
        /// Constructs AmazonSimpleEmailServiceClient with AWS Access Key ID and AWS Secret Key
        ///
        /// <param name="awsAccessKeyId">AWS Access Key ID</param>
        /// <param name="awsSecretAccessKey">AWS Secret Access Key</param>
        /// <param name="region">The region to connect.</param>
        public AmazonSimpleEmailServiceClient(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region)
            : this(awsAccessKeyId, awsSecretAccessKey, new AmazonSimpleEmailServiceConfig() {RegionEndpoint=region})
        {
        }

        ///
        /// Constructs AmazonSimpleEmailServiceClient with AWS Access Key ID, AWS Secret Key and an
        /// AmazonSimpleEmailServiceClient Configuration object.
        ///
        /// <param name="awsAccessKeyId">AWS Access Key ID</param>
        /// <param name="awsSecretAccessKey">AWS Secret Access Key</param>
        /// <param name="clientConfig">The AmazonSimpleEmailServiceClient Configuration Object</param>
        public AmazonSimpleEmailServiceClient(string awsAccessKeyId, string awsSecretAccessKey, AmazonSimpleEmailServiceConfig clientConfig)
            : base(awsAccessKeyId, awsSecretAccessKey, clientConfig)
        {
        }

        ///
        /// Constructs AmazonSimpleEmailServiceClient with AWS Access Key ID and AWS Secret Key
        ///
        /// <param name="awsAccessKeyId">AWS Access Key ID</param>
        /// <param name="awsSecretAccessKey">AWS Secret Access Key</param>
        /// <param name="awsSessionToken">AWS Session Token</param>
        public AmazonSimpleEmailServiceClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken)
            : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonSimpleEmailServiceConfig())
        {
        }

        ///
        /// Constructs AmazonSimpleEmailServiceClient with AWS Access Key ID and AWS Secret Key
        ///
        /// <param name="awsAccessKeyId">AWS Access Key ID</param>
        /// <param name="awsSecretAccessKey">AWS Secret Access Key</param>
        /// <param name="awsSessionToken">AWS Session Token</param>
        /// <param name="region">The region to connect.</param>
        public AmazonSimpleEmailServiceClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region)
            : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonSimpleEmailServiceConfig{RegionEndpoint = region})
        {
        }

        ///
        /// Constructs AmazonSimpleEmailServiceClient with AWS Access Key ID, AWS Secret Key and an
        /// AmazonSimpleEmailServiceClient Configuration object.
        ///
        /// <param name="awsAccessKeyId">AWS Access Key ID</param>
        /// <param name="awsSecretAccessKey">AWS Secret Access Key</param>
        /// <param name="awsSessionToken">AWS Session Token</param>
        /// <param name="clientConfig">The AmazonSimpleEmailServiceClient Configuration Object</param>
        public AmazonSimpleEmailServiceClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonSimpleEmailServiceConfig clientConfig)
            : base(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, clientConfig)
        {
        }

        #endregion

        #region Overrides

        ///
        /// Creates the signer for the service.
        ///
        protected override AbstractAWSSigner CreateSigner()
        {
            return new AWS4Signer();
        }

        #endregion

        #region Dispose

        ///
        /// Disposes the service client.
        ///
        protected override void Dispose(bool disposing)
        {
            base.Dispose(disposing);
        }

        #endregion

        #region  CloneReceiptRuleSet

        ///
        /// Creates a receipt rule set by cloning an existing one. All receipt rules and configurations
        /// are copied to the new receipt rule set and are completely independent of the source
        /// rule set.
        ///
        ///
        /// <para>
        /// For information about setting up rule sets, see the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the CloneReceiptRuleSet service method.</param>
        ///
        /// <returns>The response from the CloneReceiptRuleSet service method, as returned by SimpleEmailService.</returns>
        /// <exception cref="Amazon.SimpleEmail.Model.AlreadyExistsException">
        /// Indicates that a resource could not be created due to a naming conflict.
        /// </exception>
        /// <exception cref="Amazon.SimpleEmail.Model.LimitExceededException">
        /// Indicates that a resource could not be created due to service limits. For a list of
        /// Amazon SES limits, see the Amazon
        /// SES Developer Guide.
        /// </exception>
        /// <exception cref="Amazon.SimpleEmail.Model.RuleSetDoesNotExistException">
        /// Indicates that the provided receipt rule set does not exist.
        /// </exception>
        public CloneReceiptRuleSetResponse CloneReceiptRuleSet(CloneReceiptRuleSetRequest request)
        {
            var marshaller = new CloneReceiptRuleSetRequestMarshaller();
            var unmarshaller = CloneReceiptRuleSetResponseUnmarshaller.Instance;

            return Invoke<CloneReceiptRuleSetRequest,CloneReceiptRuleSetResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the CloneReceiptRuleSet operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the CloneReceiptRuleSet operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<CloneReceiptRuleSetResponse> CloneReceiptRuleSetAsync(CloneReceiptRuleSetRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new CloneReceiptRuleSetRequestMarshaller();
            var unmarshaller = CloneReceiptRuleSetResponseUnmarshaller.Instance;

            return InvokeAsync<CloneReceiptRuleSetRequest,CloneReceiptRuleSetResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  CreateReceiptFilter

        ///
        /// Creates a new IP address filter.
        ///
        ///
        /// <para>
        /// For information about setting up IP address filters, see the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the CreateReceiptFilter service method.</param>
        ///
        /// <returns>The response from the CreateReceiptFilter service method, as returned by SimpleEmailService.</returns>
        /// <exception cref="Amazon.SimpleEmail.Model.AlreadyExistsException">
        /// Indicates that a resource could not be created due to a naming conflict.
        /// </exception>
        /// <exception cref="Amazon.SimpleEmail.Model.LimitExceededException">
        /// Indicates that a resource could not be created due to service limits. For a list of
        /// Amazon SES limits, see the Amazon
        /// SES Developer Guide.
        /// </exception>
        public CreateReceiptFilterResponse CreateReceiptFilter(CreateReceiptFilterRequest request)
        {
            var marshaller = new CreateReceiptFilterRequestMarshaller();
            var unmarshaller = CreateReceiptFilterResponseUnmarshaller.Instance;

            return Invoke<CreateReceiptFilterRequest,CreateReceiptFilterResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the CreateReceiptFilter operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the CreateReceiptFilter operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<CreateReceiptFilterResponse> CreateReceiptFilterAsync(CreateReceiptFilterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new CreateReceiptFilterRequestMarshaller();
            var unmarshaller = CreateReceiptFilterResponseUnmarshaller.Instance;

            return InvokeAsync<CreateReceiptFilterRequest,CreateReceiptFilterResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  CreateReceiptRule

        ///
        /// Creates a receipt rule.
        ///
        ///
        /// <para>
        /// For information about setting up receipt rules, see the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the CreateReceiptRule service method.</param>
        ///
        /// <returns>The response from the CreateReceiptRule service method, as returned by SimpleEmailService.</returns>
        /// <exception cref="Amazon.SimpleEmail.Model.AlreadyExistsException">
        /// Indicates that a resource could not be created due to a naming conflict.
        /// </exception>
        /// <exception cref="Amazon.SimpleEmail.Model.InvalidLambdaFunctionException">
        /// Indicates that the provided AWS Lambda function is invalid, or that Amazon SES could
        /// not execute the provided function, possibly due to permissions issues. For information
        /// about giving permissions, see the Amazon
        /// SES Developer Guide.
        /// </exception>
        /// <exception cref="Amazon.SimpleEmail.Model.InvalidS3ConfigurationException">
        /// Indicates that the provided Amazon S3 bucket or AWS KMS encryption key is invalid,
        /// or that Amazon SES could not publish to the bucket, possibly due to permissions issues.
        /// For information about giving permissions, see the Amazon
        /// SES Developer Guide.
        /// </exception>
        /// <exception cref="Amazon.SimpleEmail.Model.InvalidSnsTopicException">
        /// Indicates that the provided Amazon SNS topic is invalid, or that Amazon SES could
        /// not publish to the topic, possibly due to permissions issues. For information about
        /// giving permissions, see the Amazon
        /// SES Developer Guide.
        /// </exception>
        /// <exception cref="Amazon.SimpleEmail.Model.LimitExceededException">
        /// Indicates that a resource could not be created due to service limits. For a list of
        /// Amazon SES limits, see the Amazon
        /// SES Developer Guide.
        /// </exception>
        /// <exception cref="Amazon.SimpleEmail.Model.RuleDoesNotExistException">
        /// Indicates that the provided receipt rule does not exist.
        /// </exception>
        /// <exception cref="Amazon.SimpleEmail.Model.RuleSetDoesNotExistException">
        /// Indicates that the provided receipt rule set does not exist.
        /// </exception>
        public CreateReceiptRuleResponse CreateReceiptRule(CreateReceiptRuleRequest request)
        {
            var marshaller = new CreateReceiptRuleRequestMarshaller();
            var unmarshaller = CreateReceiptRuleResponseUnmarshaller.Instance;

            return Invoke<CreateReceiptRuleRequest,CreateReceiptRuleResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the CreateReceiptRule operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the CreateReceiptRule operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<CreateReceiptRuleResponse> CreateReceiptRuleAsync(CreateReceiptRuleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new CreateReceiptRuleRequestMarshaller();
            var unmarshaller = CreateReceiptRuleResponseUnmarshaller.Instance;

            return InvokeAsync<CreateReceiptRuleRequest,CreateReceiptRuleResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  CreateReceiptRuleSet

        ///
        /// Creates an empty receipt rule set.
        ///
        ///
        /// <para>
        /// For information about setting up receipt rule sets, see the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the CreateReceiptRuleSet service method.</param>
        ///
        /// <returns>The response from the CreateReceiptRuleSet service method, as returned by SimpleEmailService.</returns>
        /// <exception cref="Amazon.SimpleEmail.Model.AlreadyExistsException">
        /// Indicates that a resource could not be created due to a naming conflict.
        /// </exception>
        /// <exception cref="Amazon.SimpleEmail.Model.LimitExceededException">
        /// Indicates that a resource could not be created due to service limits. For a list of
        /// Amazon SES limits, see the Amazon
        /// SES Developer Guide.
        /// </exception>
        public CreateReceiptRuleSetResponse CreateReceiptRuleSet(CreateReceiptRuleSetRequest request)
        {
            var marshaller = new CreateReceiptRuleSetRequestMarshaller();
            var unmarshaller = CreateReceiptRuleSetResponseUnmarshaller.Instance;

            return Invoke<CreateReceiptRuleSetRequest,CreateReceiptRuleSetResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the CreateReceiptRuleSet operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the CreateReceiptRuleSet operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<CreateReceiptRuleSetResponse> CreateReceiptRuleSetAsync(CreateReceiptRuleSetRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new CreateReceiptRuleSetRequestMarshaller();
            var unmarshaller = CreateReceiptRuleSetResponseUnmarshaller.Instance;

            return InvokeAsync<CreateReceiptRuleSetRequest,CreateReceiptRuleSetResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  DeleteIdentity

        ///
        /// Deletes the specified identity (email address or domain) from the list of verified
        /// identities.
        ///
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the DeleteIdentity service method.</param>
        ///
        /// <returns>The response from the DeleteIdentity service method, as returned by SimpleEmailService.</returns>
        public DeleteIdentityResponse DeleteIdentity(DeleteIdentityRequest request)
        {
            var marshaller = new DeleteIdentityRequestMarshaller();
            var unmarshaller = DeleteIdentityResponseUnmarshaller.Instance;

            return Invoke<DeleteIdentityRequest,DeleteIdentityResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the DeleteIdentity operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DeleteIdentity operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<DeleteIdentityResponse> DeleteIdentityAsync(DeleteIdentityRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new DeleteIdentityRequestMarshaller();
            var unmarshaller = DeleteIdentityResponseUnmarshaller.Instance;

            return InvokeAsync<DeleteIdentityRequest,DeleteIdentityResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  DeleteIdentityPolicy

        ///
        /// Deletes the specified sending authorization policy for the given identity (email address
        /// or domain). This API returns successfully even if a policy with the specified name
        /// does not exist.
        ///
        ///  <note>This API is for the identity owner only. If you have not verified the identity,
        /// this API will return an error.</note>
        /// <para>
        /// Sending authorization is a feature that enables an identity owner to authorize other
        /// senders to use its identities. For information about using sending authorization,
        /// see the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the DeleteIdentityPolicy service method.</param>
        ///
        /// <returns>The response from the DeleteIdentityPolicy service method, as returned by SimpleEmailService.</returns>
        public DeleteIdentityPolicyResponse DeleteIdentityPolicy(DeleteIdentityPolicyRequest request)
        {
            var marshaller = new DeleteIdentityPolicyRequestMarshaller();
            var unmarshaller = DeleteIdentityPolicyResponseUnmarshaller.Instance;

            return Invoke<DeleteIdentityPolicyRequest,DeleteIdentityPolicyResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the DeleteIdentityPolicy operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DeleteIdentityPolicy operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<DeleteIdentityPolicyResponse> DeleteIdentityPolicyAsync(DeleteIdentityPolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new DeleteIdentityPolicyRequestMarshaller();
            var unmarshaller = DeleteIdentityPolicyResponseUnmarshaller.Instance;

            return InvokeAsync<DeleteIdentityPolicyRequest,DeleteIdentityPolicyResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  DeleteReceiptFilter

        ///
        /// Deletes the specified IP address filter.
        ///
        ///
        /// <para>
        /// For information about managing IP address filters, see the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the DeleteReceiptFilter service method.</param>
        ///
        /// <returns>The response from the DeleteReceiptFilter service method, as returned by SimpleEmailService.</returns>
        public DeleteReceiptFilterResponse DeleteReceiptFilter(DeleteReceiptFilterRequest request)
        {
            var marshaller = new DeleteReceiptFilterRequestMarshaller();
            var unmarshaller = DeleteReceiptFilterResponseUnmarshaller.Instance;

            return Invoke<DeleteReceiptFilterRequest,DeleteReceiptFilterResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the DeleteReceiptFilter operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DeleteReceiptFilter operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<DeleteReceiptFilterResponse> DeleteReceiptFilterAsync(DeleteReceiptFilterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new DeleteReceiptFilterRequestMarshaller();
            var unmarshaller = DeleteReceiptFilterResponseUnmarshaller.Instance;

            return InvokeAsync<DeleteReceiptFilterRequest,DeleteReceiptFilterResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  DeleteReceiptRule

        ///
        /// Deletes the specified receipt rule.
        ///
        ///
        /// <para>
        /// For information about managing receipt rules, see the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the DeleteReceiptRule service method.</param>
        ///
        /// <returns>The response from the DeleteReceiptRule service method, as returned by SimpleEmailService.</returns>
        /// <exception cref="Amazon.SimpleEmail.Model.RuleSetDoesNotExistException">
        /// Indicates that the provided receipt rule set does not exist.
        /// </exception>
        public DeleteReceiptRuleResponse DeleteReceiptRule(DeleteReceiptRuleRequest request)
        {
            var marshaller = new DeleteReceiptRuleRequestMarshaller();
            var unmarshaller = DeleteReceiptRuleResponseUnmarshaller.Instance;

            return Invoke<DeleteReceiptRuleRequest,DeleteReceiptRuleResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the DeleteReceiptRule operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DeleteReceiptRule operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<DeleteReceiptRuleResponse> DeleteReceiptRuleAsync(DeleteReceiptRuleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new DeleteReceiptRuleRequestMarshaller();
            var unmarshaller = DeleteReceiptRuleResponseUnmarshaller.Instance;

            return InvokeAsync<DeleteReceiptRuleRequest,DeleteReceiptRuleResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  DeleteReceiptRuleSet

        ///
        /// Deletes the specified receipt rule set and all of the receipt rules it contains.
        ///
        ///  <note>The currently active rule set cannot be deleted.</note>
        /// <para>
        /// For information about managing receipt rule sets, see the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the DeleteReceiptRuleSet service method.</param>
        ///
        /// <returns>The response from the DeleteReceiptRuleSet service method, as returned by SimpleEmailService.</returns>
        /// <exception cref="Amazon.SimpleEmail.Model.CannotDeleteException">
        /// Indicates that the delete operation could not be completed.
        /// </exception>
        public DeleteReceiptRuleSetResponse DeleteReceiptRuleSet(DeleteReceiptRuleSetRequest request)
        {
            var marshaller = new DeleteReceiptRuleSetRequestMarshaller();
            var unmarshaller = DeleteReceiptRuleSetResponseUnmarshaller.Instance;

            return Invoke<DeleteReceiptRuleSetRequest,DeleteReceiptRuleSetResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the DeleteReceiptRuleSet operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DeleteReceiptRuleSet operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<DeleteReceiptRuleSetResponse> DeleteReceiptRuleSetAsync(DeleteReceiptRuleSetRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new DeleteReceiptRuleSetRequestMarshaller();
            var unmarshaller = DeleteReceiptRuleSetResponseUnmarshaller.Instance;

            return InvokeAsync<DeleteReceiptRuleSetRequest,DeleteReceiptRuleSetResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  DeleteVerifiedEmailAddress

        ///
        /// Deletes the specified email address from the list of verified addresses.
        ///
        ///  <important>The DeleteVerifiedEmailAddress action is deprecated as of the May 15,
        /// 2012 release of Domain Verification. The DeleteIdentity action is now preferred.</important>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the DeleteVerifiedEmailAddress service method.</param>
        ///
        /// <returns>The response from the DeleteVerifiedEmailAddress service method, as returned by SimpleEmailService.</returns>
        public DeleteVerifiedEmailAddressResponse DeleteVerifiedEmailAddress(DeleteVerifiedEmailAddressRequest request)
        {
            var marshaller = new DeleteVerifiedEmailAddressRequestMarshaller();
            var unmarshaller = DeleteVerifiedEmailAddressResponseUnmarshaller.Instance;

            return Invoke<DeleteVerifiedEmailAddressRequest,DeleteVerifiedEmailAddressResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the DeleteVerifiedEmailAddress operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DeleteVerifiedEmailAddress operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<DeleteVerifiedEmailAddressResponse> DeleteVerifiedEmailAddressAsync(DeleteVerifiedEmailAddressRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new DeleteVerifiedEmailAddressRequestMarshaller();
            var unmarshaller = DeleteVerifiedEmailAddressResponseUnmarshaller.Instance;

            return InvokeAsync<DeleteVerifiedEmailAddressRequest,DeleteVerifiedEmailAddressResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  DescribeActiveReceiptRuleSet

        ///
        /// Returns the metadata and receipt rules for the receipt rule set that is currently
        /// active.
        ///
        ///
        /// <para>
        /// For information about setting up receipt rule sets, see the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the DescribeActiveReceiptRuleSet service method.</param>
        ///
        /// <returns>The response from the DescribeActiveReceiptRuleSet service method, as returned by SimpleEmailService.</returns>
        public DescribeActiveReceiptRuleSetResponse DescribeActiveReceiptRuleSet(DescribeActiveReceiptRuleSetRequest request)
        {
            var marshaller = new DescribeActiveReceiptRuleSetRequestMarshaller();
            var unmarshaller = DescribeActiveReceiptRuleSetResponseUnmarshaller.Instance;

            return Invoke<DescribeActiveReceiptRuleSetRequest,DescribeActiveReceiptRuleSetResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the DescribeActiveReceiptRuleSet operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DescribeActiveReceiptRuleSet operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<DescribeActiveReceiptRuleSetResponse> DescribeActiveReceiptRuleSetAsync(DescribeActiveReceiptRuleSetRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new DescribeActiveReceiptRuleSetRequestMarshaller();
            var unmarshaller = DescribeActiveReceiptRuleSetResponseUnmarshaller.Instance;

            return InvokeAsync<DescribeActiveReceiptRuleSetRequest,DescribeActiveReceiptRuleSetResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  DescribeReceiptRule

        ///
        /// Returns the details of the specified receipt rule.
        ///
        ///
        /// <para>
        /// For information about setting up receipt rules, see the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the DescribeReceiptRule service method.</param>
        ///
        /// <returns>The response from the DescribeReceiptRule service method, as returned by SimpleEmailService.</returns>
        /// <exception cref="Amazon.SimpleEmail.Model.RuleDoesNotExistException">
        /// Indicates that the provided receipt rule does not exist.
        /// </exception>
        /// <exception cref="Amazon.SimpleEmail.Model.RuleSetDoesNotExistException">
        /// Indicates that the provided receipt rule set does not exist.
        /// </exception>
        public DescribeReceiptRuleResponse DescribeReceiptRule(DescribeReceiptRuleRequest request)
        {
            var marshaller = new DescribeReceiptRuleRequestMarshaller();
            var unmarshaller = DescribeReceiptRuleResponseUnmarshaller.Instance;

            return Invoke<DescribeReceiptRuleRequest,DescribeReceiptRuleResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the DescribeReceiptRule operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DescribeReceiptRule operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<DescribeReceiptRuleResponse> DescribeReceiptRuleAsync(DescribeReceiptRuleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new DescribeReceiptRuleRequestMarshaller();
            var unmarshaller = DescribeReceiptRuleResponseUnmarshaller.Instance;

            return InvokeAsync<DescribeReceiptRuleRequest,DescribeReceiptRuleResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  DescribeReceiptRuleSet

        ///
        /// Returns the details of the specified receipt rule set.
        ///
        ///
        /// <para>
        /// For information about managing receipt rule sets, see the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the DescribeReceiptRuleSet service method.</param>
        ///
        /// <returns>The response from the DescribeReceiptRuleSet service method, as returned by SimpleEmailService.</returns>
        /// <exception cref="Amazon.SimpleEmail.Model.RuleSetDoesNotExistException">
        /// Indicates that the provided receipt rule set does not exist.
        /// </exception>
        public DescribeReceiptRuleSetResponse DescribeReceiptRuleSet(DescribeReceiptRuleSetRequest request)
        {
            var marshaller = new DescribeReceiptRuleSetRequestMarshaller();
            var unmarshaller = DescribeReceiptRuleSetResponseUnmarshaller.Instance;

            return Invoke<DescribeReceiptRuleSetRequest,DescribeReceiptRuleSetResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the DescribeReceiptRuleSet operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DescribeReceiptRuleSet operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<DescribeReceiptRuleSetResponse> DescribeReceiptRuleSetAsync(DescribeReceiptRuleSetRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new DescribeReceiptRuleSetRequestMarshaller();
            var unmarshaller = DescribeReceiptRuleSetResponseUnmarshaller.Instance;

            return InvokeAsync<DescribeReceiptRuleSetRequest,DescribeReceiptRuleSetResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  GetIdentityDkimAttributes

        ///
        /// Returns the current status of Easy DKIM signing for an entity. For domain name identities,
        /// this action also returns the DKIM tokens that are required for Easy DKIM signing,
        /// and whether Amazon SES has successfully verified that these tokens have been published.
        ///
        ///
        /// <para>
        /// This action takes a list of identities as input and returns the following information
        /// for each:
        /// </para>
        ///

Whether Easy DKIM signing is enabled or disabled.

A set of DKIM
        /// tokens that represent the identity. If the identity is an email address, the tokens
        /// represent the domain of that address.

Whether Amazon SES has successfully
        /// verified the DKIM tokens published in the domain's DNS. This information is only returned
        /// for domain name identities, not for email addresses.

        /// <para>
        /// This action is throttled at one request per second and can only get DKIM attributes
        /// for up to 100 identities at a time.
        /// </para>
        ///
        /// <para>
        /// For more information about creating DNS records using DKIM tokens, go to the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the GetIdentityDkimAttributes service method.</param>
        ///
        /// <returns>The response from the GetIdentityDkimAttributes service method, as returned by SimpleEmailService.</returns>
        public GetIdentityDkimAttributesResponse GetIdentityDkimAttributes(GetIdentityDkimAttributesRequest request)
        {
            var marshaller = new GetIdentityDkimAttributesRequestMarshaller();
            var unmarshaller = GetIdentityDkimAttributesResponseUnmarshaller.Instance;

            return Invoke<GetIdentityDkimAttributesRequest,GetIdentityDkimAttributesResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the GetIdentityDkimAttributes operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the GetIdentityDkimAttributes operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<GetIdentityDkimAttributesResponse> GetIdentityDkimAttributesAsync(GetIdentityDkimAttributesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new GetIdentityDkimAttributesRequestMarshaller();
            var unmarshaller = GetIdentityDkimAttributesResponseUnmarshaller.Instance;

            return InvokeAsync<GetIdentityDkimAttributesRequest,GetIdentityDkimAttributesResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  GetIdentityNotificationAttributes

        ///
        /// Given a list of verified identities (email addresses and/or domains), returns a structure
        /// describing identity notification attributes.
        ///
        ///
        /// <para>
        /// This action is throttled at one request per second and can only get notification attributes
        /// for up to 100 identities at a time.
        /// </para>
        ///
        /// <para>
        /// For more information about using notifications with Amazon SES, see the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the GetIdentityNotificationAttributes service method.</param>
        ///
        /// <returns>The response from the GetIdentityNotificationAttributes service method, as returned by SimpleEmailService.</returns>
        public GetIdentityNotificationAttributesResponse GetIdentityNotificationAttributes(GetIdentityNotificationAttributesRequest request)
        {
            var marshaller = new GetIdentityNotificationAttributesRequestMarshaller();
            var unmarshaller = GetIdentityNotificationAttributesResponseUnmarshaller.Instance;

            return Invoke<GetIdentityNotificationAttributesRequest,GetIdentityNotificationAttributesResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the GetIdentityNotificationAttributes operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the GetIdentityNotificationAttributes operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<GetIdentityNotificationAttributesResponse> GetIdentityNotificationAttributesAsync(GetIdentityNotificationAttributesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new GetIdentityNotificationAttributesRequestMarshaller();
            var unmarshaller = GetIdentityNotificationAttributesResponseUnmarshaller.Instance;

            return InvokeAsync<GetIdentityNotificationAttributesRequest,GetIdentityNotificationAttributesResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  GetIdentityPolicies

        ///
        /// Returns the requested sending authorization policies for the given identity (email
        /// address or domain). The policies are returned as a map of policy names to policy contents.
        /// You can retrieve a maximum of 20 policies at a time.
        ///
        ///  <note>This API is for the identity owner only. If you have not verified the identity,
        /// this API will return an error.</note>
        /// <para>
        /// Sending authorization is a feature that enables an identity owner to authorize other
        /// senders to use its identities. For information about using sending authorization,
        /// see the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the GetIdentityPolicies service method.</param>
        ///
        /// <returns>The response from the GetIdentityPolicies service method, as returned by SimpleEmailService.</returns>
        public GetIdentityPoliciesResponse GetIdentityPolicies(GetIdentityPoliciesRequest request)
        {
            var marshaller = new GetIdentityPoliciesRequestMarshaller();
            var unmarshaller = GetIdentityPoliciesResponseUnmarshaller.Instance;

            return Invoke<GetIdentityPoliciesRequest,GetIdentityPoliciesResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the GetIdentityPolicies operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the GetIdentityPolicies operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<GetIdentityPoliciesResponse> GetIdentityPoliciesAsync(GetIdentityPoliciesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new GetIdentityPoliciesRequestMarshaller();
            var unmarshaller = GetIdentityPoliciesResponseUnmarshaller.Instance;

            return InvokeAsync<GetIdentityPoliciesRequest,GetIdentityPoliciesResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  GetIdentityVerificationAttributes

        ///
        /// Given a list of identities (email addresses and/or domains), returns the verification
        /// status and (for domain identities) the verification token for each identity.
        ///
        ///
        /// <para>
        /// This action is throttled at one request per second and can only get verification attributes
        /// for up to 100 identities at a time.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the GetIdentityVerificationAttributes service method.</param>
        ///
        /// <returns>The response from the GetIdentityVerificationAttributes service method, as returned by SimpleEmailService.</returns>
        public GetIdentityVerificationAttributesResponse GetIdentityVerificationAttributes(GetIdentityVerificationAttributesRequest request)
        {
            var marshaller = new GetIdentityVerificationAttributesRequestMarshaller();
            var unmarshaller = GetIdentityVerificationAttributesResponseUnmarshaller.Instance;

            return Invoke<GetIdentityVerificationAttributesRequest,GetIdentityVerificationAttributesResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the GetIdentityVerificationAttributes operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the GetIdentityVerificationAttributes operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<GetIdentityVerificationAttributesResponse> GetIdentityVerificationAttributesAsync(GetIdentityVerificationAttributesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new GetIdentityVerificationAttributesRequestMarshaller();
            var unmarshaller = GetIdentityVerificationAttributesResponseUnmarshaller.Instance;

            return InvokeAsync<GetIdentityVerificationAttributesRequest,GetIdentityVerificationAttributesResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  GetSendQuota

        ///
        /// Returns the user's current sending limits.
        ///
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        ///
        /// <returns>The response from the GetSendQuota service method, as returned by SimpleEmailService.</returns>
        public GetSendQuotaResponse GetSendQuota()
        {
            return GetSendQuota(new GetSendQuotaRequest());
        }

        ///
        /// Returns the user's current sending limits.
        ///
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the GetSendQuota service method.</param>
        ///
        /// <returns>The response from the GetSendQuota service method, as returned by SimpleEmailService.</returns>
        public GetSendQuotaResponse GetSendQuota(GetSendQuotaRequest request)
        {
            var marshaller = new GetSendQuotaRequestMarshaller();
            var unmarshaller = GetSendQuotaResponseUnmarshaller.Instance;

            return Invoke<GetSendQuotaRequest,GetSendQuotaResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Returns the user's current sending limits.
        ///
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="cancellationToken"> ttd1
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        ///
        /// <returns>The response from the GetSendQuota service method, as returned by SimpleEmailService.</returns>
        public Task<GetSendQuotaResponse> GetSendQuotaAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            return GetSendQuotaAsync(new GetSendQuotaRequest(), cancellationToken);
        }
        ///
        /// Initiates the asynchronous execution of the GetSendQuota operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the GetSendQuota operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<GetSendQuotaResponse> GetSendQuotaAsync(GetSendQuotaRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new GetSendQuotaRequestMarshaller();
            var unmarshaller = GetSendQuotaResponseUnmarshaller.Instance;

            return InvokeAsync<GetSendQuotaRequest,GetSendQuotaResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  GetSendStatistics

        ///
        /// Returns the user's sending statistics. The result is a list of data points, representing
        /// the last two weeks of sending activity.
        ///
        ///
        /// <para>
        /// Each data point in the list contains statistics for a 15-minute interval.
        /// </para>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        ///
        /// <returns>The response from the GetSendStatistics service method, as returned by SimpleEmailService.</returns>
        public GetSendStatisticsResponse GetSendStatistics()
        {
            return GetSendStatistics(new GetSendStatisticsRequest());
        }

        ///
        /// Returns the user's sending statistics. The result is a list of data points, representing
        /// the last two weeks of sending activity.
        ///
        ///
        /// <para>
        /// Each data point in the list contains statistics for a 15-minute interval.
        /// </para>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the GetSendStatistics service method.</param>
        ///
        /// <returns>The response from the GetSendStatistics service method, as returned by SimpleEmailService.</returns>
        public GetSendStatisticsResponse GetSendStatistics(GetSendStatisticsRequest request)
        {
            var marshaller = new GetSendStatisticsRequestMarshaller();
            var unmarshaller = GetSendStatisticsResponseUnmarshaller.Instance;

            return Invoke<GetSendStatisticsRequest,GetSendStatisticsResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Returns the user's sending statistics. The result is a list of data points, representing
        /// the last two weeks of sending activity.
        ///
        ///
        /// <para>
        /// Each data point in the list contains statistics for a 15-minute interval.
        /// </para>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="cancellationToken"> ttd1
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        ///
        /// <returns>The response from the GetSendStatistics service method, as returned by SimpleEmailService.</returns>
        public Task<GetSendStatisticsResponse> GetSendStatisticsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            return GetSendStatisticsAsync(new GetSendStatisticsRequest(), cancellationToken);
        }
        ///
        /// Initiates the asynchronous execution of the GetSendStatistics operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the GetSendStatistics operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<GetSendStatisticsResponse> GetSendStatisticsAsync(GetSendStatisticsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new GetSendStatisticsRequestMarshaller();
            var unmarshaller = GetSendStatisticsResponseUnmarshaller.Instance;

            return InvokeAsync<GetSendStatisticsRequest,GetSendStatisticsResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  ListIdentities

        ///
        /// Returns a list containing all of the identities (email addresses and domains) for
        /// a specific AWS Account, regardless of verification status.
        ///
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        ///
        /// <returns>The response from the ListIdentities service method, as returned by SimpleEmailService.</returns>
        public ListIdentitiesResponse ListIdentities()
        {
            return ListIdentities(new ListIdentitiesRequest());
        }

        ///
        /// Returns a list containing all of the identities (email addresses and domains) for
        /// a specific AWS Account, regardless of verification status.
        ///
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the ListIdentities service method.</param>
        ///
        /// <returns>The response from the ListIdentities service method, as returned by SimpleEmailService.</returns>
        public ListIdentitiesResponse ListIdentities(ListIdentitiesRequest request)
        {
            var marshaller = new ListIdentitiesRequestMarshaller();
            var unmarshaller = ListIdentitiesResponseUnmarshaller.Instance;

            return Invoke<ListIdentitiesRequest,ListIdentitiesResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Returns a list containing all of the identities (email addresses and domains) for
        /// a specific AWS Account, regardless of verification status.
        ///
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="cancellationToken"> ttd1
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        ///
        /// <returns>The response from the ListIdentities service method, as returned by SimpleEmailService.</returns>
        public Task<ListIdentitiesResponse> ListIdentitiesAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            return ListIdentitiesAsync(new ListIdentitiesRequest(), cancellationToken);
        }
        ///
        /// Initiates the asynchronous execution of the ListIdentities operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the ListIdentities operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<ListIdentitiesResponse> ListIdentitiesAsync(ListIdentitiesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new ListIdentitiesRequestMarshaller();
            var unmarshaller = ListIdentitiesResponseUnmarshaller.Instance;

            return InvokeAsync<ListIdentitiesRequest,ListIdentitiesResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  ListIdentityPolicies

        ///
        /// Returns a list of sending authorization policies that are attached to the given identity
        /// (email address or domain). This API returns only a list. If you want the actual policy
        /// content, you can use GetIdentityPolicies.
        ///
        ///  <note>This API is for the identity owner only. If you have not verified the identity,
        /// this API will return an error.</note>
        /// <para>
        /// Sending authorization is a feature that enables an identity owner to authorize other
        /// senders to use its identities. For information about using sending authorization,
        /// see the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the ListIdentityPolicies service method.</param>
        ///
        /// <returns>The response from the ListIdentityPolicies service method, as returned by SimpleEmailService.</returns>
        public ListIdentityPoliciesResponse ListIdentityPolicies(ListIdentityPoliciesRequest request)
        {
            var marshaller = new ListIdentityPoliciesRequestMarshaller();
            var unmarshaller = ListIdentityPoliciesResponseUnmarshaller.Instance;

            return Invoke<ListIdentityPoliciesRequest,ListIdentityPoliciesResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the ListIdentityPolicies operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the ListIdentityPolicies operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<ListIdentityPoliciesResponse> ListIdentityPoliciesAsync(ListIdentityPoliciesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new ListIdentityPoliciesRequestMarshaller();
            var unmarshaller = ListIdentityPoliciesResponseUnmarshaller.Instance;

            return InvokeAsync<ListIdentityPoliciesRequest,ListIdentityPoliciesResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  ListReceiptFilters

        ///
        /// Lists the IP address filters associated with your account.
        ///
        ///
        /// <para>
        /// For information about managing IP address filters, see the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the ListReceiptFilters service method.</param>
        ///
        /// <returns>The response from the ListReceiptFilters service method, as returned by SimpleEmailService.</returns>
        public ListReceiptFiltersResponse ListReceiptFilters(ListReceiptFiltersRequest request)
        {
            var marshaller = new ListReceiptFiltersRequestMarshaller();
            var unmarshaller = ListReceiptFiltersResponseUnmarshaller.Instance;

            return Invoke<ListReceiptFiltersRequest,ListReceiptFiltersResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the ListReceiptFilters operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the ListReceiptFilters operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<ListReceiptFiltersResponse> ListReceiptFiltersAsync(ListReceiptFiltersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new ListReceiptFiltersRequestMarshaller();
            var unmarshaller = ListReceiptFiltersResponseUnmarshaller.Instance;

            return InvokeAsync<ListReceiptFiltersRequest,ListReceiptFiltersResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  ListReceiptRuleSets

        ///
        /// Lists the receipt rule sets that exist under your AWS account. If there are additional
        /// receipt rule sets to be retrieved, you will receive a NextToken that
        /// you can provide to the next call to ListReceiptRuleSets to retrieve the
        /// additional entries.
        ///
        ///
        /// <para>
        /// For information about managing receipt rule sets, see the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the ListReceiptRuleSets service method.</param>
        ///
        /// <returns>The response from the ListReceiptRuleSets service method, as returned by SimpleEmailService.</returns>
        public ListReceiptRuleSetsResponse ListReceiptRuleSets(ListReceiptRuleSetsRequest request)
        {
            var marshaller = new ListReceiptRuleSetsRequestMarshaller();
            var unmarshaller = ListReceiptRuleSetsResponseUnmarshaller.Instance;

            return Invoke<ListReceiptRuleSetsRequest,ListReceiptRuleSetsResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the ListReceiptRuleSets operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the ListReceiptRuleSets operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<ListReceiptRuleSetsResponse> ListReceiptRuleSetsAsync(ListReceiptRuleSetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new ListReceiptRuleSetsRequestMarshaller();
            var unmarshaller = ListReceiptRuleSetsResponseUnmarshaller.Instance;

            return InvokeAsync<ListReceiptRuleSetsRequest,ListReceiptRuleSetsResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  ListVerifiedEmailAddresses

        ///
        /// Returns a list containing all of the email addresses that have been verified.
        ///
        ///  <important>The ListVerifiedEmailAddresses action is deprecated as of the May 15,
        /// 2012 release of Domain Verification. The ListIdentities action is now preferred.</important>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        ///
        /// <returns>The response from the ListVerifiedEmailAddresses service method, as returned by SimpleEmailService.</returns>
        public ListVerifiedEmailAddressesResponse ListVerifiedEmailAddresses()
        {
            return ListVerifiedEmailAddresses(new ListVerifiedEmailAddressesRequest());
        }

        ///
        /// Returns a list containing all of the email addresses that have been verified.
        ///
        ///  <important>The ListVerifiedEmailAddresses action is deprecated as of the May 15,
        /// 2012 release of Domain Verification. The ListIdentities action is now preferred.</important>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the ListVerifiedEmailAddresses service method.</param>
        ///
        /// <returns>The response from the ListVerifiedEmailAddresses service method, as returned by SimpleEmailService.</returns>
        public ListVerifiedEmailAddressesResponse ListVerifiedEmailAddresses(ListVerifiedEmailAddressesRequest request)
        {
            var marshaller = new ListVerifiedEmailAddressesRequestMarshaller();
            var unmarshaller = ListVerifiedEmailAddressesResponseUnmarshaller.Instance;

            return Invoke<ListVerifiedEmailAddressesRequest,ListVerifiedEmailAddressesResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Returns a list containing all of the email addresses that have been verified.
        ///
        ///  <important>The ListVerifiedEmailAddresses action is deprecated as of the May 15,
        /// 2012 release of Domain Verification. The ListIdentities action is now preferred.</important>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="cancellationToken"> ttd1
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        ///
        /// <returns>The response from the ListVerifiedEmailAddresses service method, as returned by SimpleEmailService.</returns>
        public Task<ListVerifiedEmailAddressesResponse> ListVerifiedEmailAddressesAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            return ListVerifiedEmailAddressesAsync(new ListVerifiedEmailAddressesRequest(), cancellationToken);
        }
        ///
        /// Initiates the asynchronous execution of the ListVerifiedEmailAddresses operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the ListVerifiedEmailAddresses operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<ListVerifiedEmailAddressesResponse> ListVerifiedEmailAddressesAsync(ListVerifiedEmailAddressesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new ListVerifiedEmailAddressesRequestMarshaller();
            var unmarshaller = ListVerifiedEmailAddressesResponseUnmarshaller.Instance;

            return InvokeAsync<ListVerifiedEmailAddressesRequest,ListVerifiedEmailAddressesResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  PutIdentityPolicy

        ///
        /// Adds or updates a sending authorization policy for the specified identity (email address
        /// or domain).
        ///
        ///  <note>This API is for the identity owner only. If you have not verified the identity,
        /// this API will return an error.</note>
        /// <para>
        /// Sending authorization is a feature that enables an identity owner to authorize other
        /// senders to use its identities. For information about using sending authorization,
        /// see the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the PutIdentityPolicy service method.</param>
        ///
        /// <returns>The response from the PutIdentityPolicy service method, as returned by SimpleEmailService.</returns>
        /// <exception cref="Amazon.SimpleEmail.Model.InvalidPolicyException">
        /// Indicates that the provided policy is invalid. Check the error stack for more information
        /// about what caused the error.
        /// </exception>
        public PutIdentityPolicyResponse PutIdentityPolicy(PutIdentityPolicyRequest request)
        {
            var marshaller = new PutIdentityPolicyRequestMarshaller();
            var unmarshaller = PutIdentityPolicyResponseUnmarshaller.Instance;

            return Invoke<PutIdentityPolicyRequest,PutIdentityPolicyResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the PutIdentityPolicy operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the PutIdentityPolicy operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<PutIdentityPolicyResponse> PutIdentityPolicyAsync(PutIdentityPolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new PutIdentityPolicyRequestMarshaller();
            var unmarshaller = PutIdentityPolicyResponseUnmarshaller.Instance;

            return InvokeAsync<PutIdentityPolicyRequest,PutIdentityPolicyResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  ReorderReceiptRuleSet

        ///
        /// Reorders the receipt rules within a receipt rule set.
        ///
        ///  <note>All of the rules in the rule set must be represented in this request. That
        /// is, this API will return an error if the reorder request doesn't explicitly position
        /// all of the rules.</note>
        /// <para>
        /// For information about managing receipt rule sets, see the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the ReorderReceiptRuleSet service method.</param>
        ///
        /// <returns>The response from the ReorderReceiptRuleSet service method, as returned by SimpleEmailService.</returns>
        /// <exception cref="Amazon.SimpleEmail.Model.RuleDoesNotExistException">
        /// Indicates that the provided receipt rule does not exist.
        /// </exception>
        /// <exception cref="Amazon.SimpleEmail.Model.RuleSetDoesNotExistException">
        /// Indicates that the provided receipt rule set does not exist.
        /// </exception>
        public ReorderReceiptRuleSetResponse ReorderReceiptRuleSet(ReorderReceiptRuleSetRequest request)
        {
            var marshaller = new ReorderReceiptRuleSetRequestMarshaller();
            var unmarshaller = ReorderReceiptRuleSetResponseUnmarshaller.Instance;

            return Invoke<ReorderReceiptRuleSetRequest,ReorderReceiptRuleSetResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the ReorderReceiptRuleSet operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the ReorderReceiptRuleSet operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<ReorderReceiptRuleSetResponse> ReorderReceiptRuleSetAsync(ReorderReceiptRuleSetRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new ReorderReceiptRuleSetRequestMarshaller();
            var unmarshaller = ReorderReceiptRuleSetResponseUnmarshaller.Instance;

            return InvokeAsync<ReorderReceiptRuleSetRequest,ReorderReceiptRuleSetResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  SendBounce

        ///
        /// Generates and sends a bounce message to the sender of an email you received through
        /// Amazon SES. You can only use this API on an email up to 24 hours after you receive
        /// it.
        ///
        ///  <note>You cannot use this API to send generic bounces for mail that was not received
        /// by Amazon SES.</note>
        /// <para>
        /// For information about receiving email through Amazon SES, see the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the SendBounce service method.</param>
        ///
        /// <returns>The response from the SendBounce service method, as returned by SimpleEmailService.</returns>
        /// <exception cref="Amazon.SimpleEmail.Model.MessageRejectedException">
        /// Indicates that the action failed, and the message could not be sent. Check the error
        /// stack for more information about what caused the error.
        /// </exception>
        public SendBounceResponse SendBounce(SendBounceRequest request)
        {
            var marshaller = new SendBounceRequestMarshaller();
            var unmarshaller = SendBounceResponseUnmarshaller.Instance;

            return Invoke<SendBounceRequest,SendBounceResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the SendBounce operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the SendBounce operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<SendBounceResponse> SendBounceAsync(SendBounceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new SendBounceRequestMarshaller();
            var unmarshaller = SendBounceResponseUnmarshaller.Instance;

            return InvokeAsync<SendBounceRequest,SendBounceResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  SendEmail

        ///
        /// Composes an email message based on input data, and then immediately queues the message
        /// for sending.
        ///
        ///
        /// <para>
        /// There are several important points to know about SendEmail:
        /// </para>
        ///

You can only send email from verified email addresses and domains; otherwise,
        /// you will get an "Email address not verified" error. If your account is still in the
        /// Amazon SES sandbox, you must also verify every recipient email address except for
        /// the recipients provided by the Amazon SES mailbox simulator. For more information,
        /// go to the Amazon
        /// SES Developer Guide.

The total size of the message cannot exceed 10 MB.
        /// This includes any attachments that are part of the message.

Amazon SES has
        /// a limit on the total number of recipients per message. The combined number of To:,
        /// CC: and BCC: email addresses cannot exceed 50. If you need to send an email message
        /// to a larger audience, you can divide your recipient list into groups of 50 or fewer,
        /// and then call Amazon SES repeatedly to send the message to each group.

For
        /// every message that you send, the total number of recipients (To:, CC: and BCC:) is
        /// counted against your sending quota - the maximum number of emails you can send in
        /// a 24-hour period. For information about your sending quota, go to the Amazon
        /// SES Developer Guide.

        ///
        /// <param name="request">Container for the necessary parameters to execute the SendEmail service method.</param>
        ///
        /// <returns>The response from the SendEmail service method, as returned by SimpleEmailService.</returns>
        /// <exception cref="Amazon.SimpleEmail.Model.MessageRejectedException">
        /// Indicates that the action failed, and the message could not be sent. Check the error
        /// stack for more information about what caused the error.
        /// </exception>
        public SendEmailResponse SendEmail(SendEmailRequest request)
        {
            var marshaller = new SendEmailRequestMarshaller();
            var unmarshaller = SendEmailResponseUnmarshaller.Instance;

            return Invoke<SendEmailRequest,SendEmailResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the SendEmail operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the SendEmail operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<SendEmailResponse> SendEmailAsync(SendEmailRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new SendEmailRequestMarshaller();
            var unmarshaller = SendEmailResponseUnmarshaller.Instance;

            return InvokeAsync<SendEmailRequest,SendEmailResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  SendRawEmail

        ///
        /// Sends an email message, with header and content specified by the client. The SendRawEmail
        /// action is useful for sending multipart MIME emails. The raw text of the message must
        /// comply with Internet email standards; otherwise, the message cannot be sent.
        ///
        ///
        /// <para>
        /// There are several important points to know about SendRawEmail:
        /// </para>
        ///

You can only send email from verified email addresses and domains; otherwise,
        /// you will get an "Email address not verified" error. If your account is still in the
        /// Amazon SES sandbox, you must also verify every recipient email address except for
        /// the recipients provided by the Amazon SES mailbox simulator. For more information,
        /// go to the Amazon
        /// SES Developer Guide.

The total size of the message cannot exceed 10 MB.
        /// This includes any attachments that are part of the message.

Amazon SES has
        /// a limit on the total number of recipients per message. The combined number of To:,
        /// CC: and BCC: email addresses cannot exceed 50. If you need to send an email message
        /// to a larger audience, you can divide your recipient list into groups of 50 or fewer,
        /// and then call Amazon SES repeatedly to send the message to each group.

The
        /// To:, CC:, and BCC: headers in the raw message can contain a group list. Note that
        /// each recipient in a group list counts towards the 50-recipient limit.

For
        /// every message that you send, the total number of recipients (To:, CC: and BCC:) is
        /// counted against your sending quota - the maximum number of emails you can send in
        /// a 24-hour period. For information about your sending quota, go to the Amazon
        /// SES Developer Guide.

If you are using sending authorization to send on
        /// behalf of another user, SendRawEmail enables you to specify the cross-account
        /// identity for the email's "Source," "From," and "Return-Path" parameters in one of
        /// two ways: you can pass optional parameters SourceArn, FromArn,
        /// and/or ReturnPathArn to the API, or you can include the following X-headers
        /// in the header of your raw email:

X-SES-SOURCE-ARN

X-SES-FROM-ARN

        ///
X-SES-RETURN-PATH-ARN

 <important>Do not include these
        /// X-headers in the DKIM signature, because they are removed by Amazon SES before sending
        /// the email.</important> For the most common sending authorization use case, we recommend
        /// that you specify the SourceIdentityArn and do not specify either the
        /// FromIdentityArn or ReturnPathIdentityArn. (The same note
        /// applies to the corresponding X-headers.) If you only specify the SourceIdentityArn,
        /// Amazon SES will simply set the "From" address and the "Return Path" address to the
        /// identity specified in SourceIdentityArn. For more information about sending
        /// authorization, see the Amazon
        /// SES Developer Guide.

        ///
        /// <param name="request">Container for the necessary parameters to execute the SendRawEmail service method.</param>
        ///
        /// <returns>The response from the SendRawEmail service method, as returned by SimpleEmailService.</returns>
        /// <exception cref="Amazon.SimpleEmail.Model.MessageRejectedException">
        /// Indicates that the action failed, and the message could not be sent. Check the error
        /// stack for more information about what caused the error.
        /// </exception>
        public SendRawEmailResponse SendRawEmail(SendRawEmailRequest request)
        {
            var marshaller = new SendRawEmailRequestMarshaller();
            var unmarshaller = SendRawEmailResponseUnmarshaller.Instance;

            return Invoke<SendRawEmailRequest,SendRawEmailResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the SendRawEmail operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the SendRawEmail operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<SendRawEmailResponse> SendRawEmailAsync(SendRawEmailRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new SendRawEmailRequestMarshaller();
            var unmarshaller = SendRawEmailResponseUnmarshaller.Instance;

            return InvokeAsync<SendRawEmailRequest,SendRawEmailResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  SetActiveReceiptRuleSet

        ///
        /// Sets the specified receipt rule set as the active receipt rule set.
        ///
        ///  <note>To disable your email-receiving through Amazon SES completely, you can call
        /// this API with RuleSetName set to null.</note>
        /// <para>
        /// For information about managing receipt rule sets, see the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the SetActiveReceiptRuleSet service method.</param>
        ///
        /// <returns>The response from the SetActiveReceiptRuleSet service method, as returned by SimpleEmailService.</returns>
        /// <exception cref="Amazon.SimpleEmail.Model.RuleSetDoesNotExistException">
        /// Indicates that the provided receipt rule set does not exist.
        /// </exception>
        public SetActiveReceiptRuleSetResponse SetActiveReceiptRuleSet(SetActiveReceiptRuleSetRequest request)
        {
            var marshaller = new SetActiveReceiptRuleSetRequestMarshaller();
            var unmarshaller = SetActiveReceiptRuleSetResponseUnmarshaller.Instance;

            return Invoke<SetActiveReceiptRuleSetRequest,SetActiveReceiptRuleSetResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the SetActiveReceiptRuleSet operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the SetActiveReceiptRuleSet operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<SetActiveReceiptRuleSetResponse> SetActiveReceiptRuleSetAsync(SetActiveReceiptRuleSetRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new SetActiveReceiptRuleSetRequestMarshaller();
            var unmarshaller = SetActiveReceiptRuleSetResponseUnmarshaller.Instance;

            return InvokeAsync<SetActiveReceiptRuleSetRequest,SetActiveReceiptRuleSetResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  SetIdentityDkimEnabled

        ///
        /// Enables or disables Easy DKIM signing of email sent from an identity:
        ///
        ///

If Easy DKIM signing is enabled for a domain name identity (e.g., example.com),
        /// then Amazon SES will DKIM-sign all email sent by addresses under that domain name
        /// (e.g., user@example.com).

If Easy DKIM signing is enabled for
        /// an email address, then Amazon SES will DKIM-sign all email sent by that email address.

        ///

        /// <para>
        /// For email addresses (e.g., user@example.com), you can only enable Easy
        /// DKIM signing if the corresponding domain (e.g., example.com) has been
        /// set up for Easy DKIM using the AWS Console or the VerifyDomainDkim action.
        /// </para>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <para>
        /// For more information about Easy DKIM signing, go to the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the SetIdentityDkimEnabled service method.</param>
        ///
        /// <returns>The response from the SetIdentityDkimEnabled service method, as returned by SimpleEmailService.</returns>
        public SetIdentityDkimEnabledResponse SetIdentityDkimEnabled(SetIdentityDkimEnabledRequest request)
        {
            var marshaller = new SetIdentityDkimEnabledRequestMarshaller();
            var unmarshaller = SetIdentityDkimEnabledResponseUnmarshaller.Instance;

            return Invoke<SetIdentityDkimEnabledRequest,SetIdentityDkimEnabledResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the SetIdentityDkimEnabled operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the SetIdentityDkimEnabled operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<SetIdentityDkimEnabledResponse> SetIdentityDkimEnabledAsync(SetIdentityDkimEnabledRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new SetIdentityDkimEnabledRequestMarshaller();
            var unmarshaller = SetIdentityDkimEnabledResponseUnmarshaller.Instance;

            return InvokeAsync<SetIdentityDkimEnabledRequest,SetIdentityDkimEnabledResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  SetIdentityFeedbackForwardingEnabled

        ///
        /// Given an identity (email address or domain), enables or disables whether Amazon SES
        /// forwards bounce and complaint notifications as email. Feedback forwarding can only
        /// be disabled when Amazon Simple Notification Service (Amazon SNS) topics are specified
        /// for both bounces and complaints.
        ///
        ///  <note>Feedback forwarding does not apply to delivery notifications. Delivery notifications
        /// are only available through Amazon SNS.</note>
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <para>
        /// For more information about using notifications with Amazon SES, see the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the SetIdentityFeedbackForwardingEnabled service method.</param>
        ///
        /// <returns>The response from the SetIdentityFeedbackForwardingEnabled service method, as returned by SimpleEmailService.</returns>
        public SetIdentityFeedbackForwardingEnabledResponse SetIdentityFeedbackForwardingEnabled(SetIdentityFeedbackForwardingEnabledRequest request)
        {
            var marshaller = new SetIdentityFeedbackForwardingEnabledRequestMarshaller();
            var unmarshaller = SetIdentityFeedbackForwardingEnabledResponseUnmarshaller.Instance;

            return Invoke<SetIdentityFeedbackForwardingEnabledRequest,SetIdentityFeedbackForwardingEnabledResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the SetIdentityFeedbackForwardingEnabled operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the SetIdentityFeedbackForwardingEnabled operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<SetIdentityFeedbackForwardingEnabledResponse> SetIdentityFeedbackForwardingEnabledAsync(SetIdentityFeedbackForwardingEnabledRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new SetIdentityFeedbackForwardingEnabledRequestMarshaller();
            var unmarshaller = SetIdentityFeedbackForwardingEnabledResponseUnmarshaller.Instance;

            return InvokeAsync<SetIdentityFeedbackForwardingEnabledRequest,SetIdentityFeedbackForwardingEnabledResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  SetIdentityNotificationTopic

        ///
        /// Given an identity (email address or domain), sets the Amazon Simple Notification Service
        /// (Amazon SNS) topic to which Amazon SES will publish bounce, complaint, and/or delivery
        /// notifications for emails sent with that identity as the Source.
        ///
        ///  <note>Unless feedback forwarding is enabled, you must specify Amazon SNS topics for
        /// bounce and complaint notifications. For more information, see SetIdentityFeedbackForwardingEnabled.
        /// </note>
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <para>
        /// For more information about feedback notification, see the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the SetIdentityNotificationTopic service method.</param>
        ///
        /// <returns>The response from the SetIdentityNotificationTopic service method, as returned by SimpleEmailService.</returns>
        public SetIdentityNotificationTopicResponse SetIdentityNotificationTopic(SetIdentityNotificationTopicRequest request)
        {
            var marshaller = new SetIdentityNotificationTopicRequestMarshaller();
            var unmarshaller = SetIdentityNotificationTopicResponseUnmarshaller.Instance;

            return Invoke<SetIdentityNotificationTopicRequest,SetIdentityNotificationTopicResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the SetIdentityNotificationTopic operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the SetIdentityNotificationTopic operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<SetIdentityNotificationTopicResponse> SetIdentityNotificationTopicAsync(SetIdentityNotificationTopicRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new SetIdentityNotificationTopicRequestMarshaller();
            var unmarshaller = SetIdentityNotificationTopicResponseUnmarshaller.Instance;

            return InvokeAsync<SetIdentityNotificationTopicRequest,SetIdentityNotificationTopicResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  SetReceiptRulePosition

        ///
        /// Sets the position of the specified receipt rule in the receipt rule set.
        ///
        ///
        /// <para>
        /// For information about managing receipt rules, see the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the SetReceiptRulePosition service method.</param>
        ///
        /// <returns>The response from the SetReceiptRulePosition service method, as returned by SimpleEmailService.</returns>
        /// <exception cref="Amazon.SimpleEmail.Model.RuleDoesNotExistException">
        /// Indicates that the provided receipt rule does not exist.
        /// </exception>
        /// <exception cref="Amazon.SimpleEmail.Model.RuleSetDoesNotExistException">
        /// Indicates that the provided receipt rule set does not exist.
        /// </exception>
        public SetReceiptRulePositionResponse SetReceiptRulePosition(SetReceiptRulePositionRequest request)
        {
            var marshaller = new SetReceiptRulePositionRequestMarshaller();
            var unmarshaller = SetReceiptRulePositionResponseUnmarshaller.Instance;

            return Invoke<SetReceiptRulePositionRequest,SetReceiptRulePositionResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the SetReceiptRulePosition operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the SetReceiptRulePosition operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<SetReceiptRulePositionResponse> SetReceiptRulePositionAsync(SetReceiptRulePositionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new SetReceiptRulePositionRequestMarshaller();
            var unmarshaller = SetReceiptRulePositionResponseUnmarshaller.Instance;

            return InvokeAsync<SetReceiptRulePositionRequest,SetReceiptRulePositionResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  UpdateReceiptRule

        ///
        /// Updates a receipt rule.
        ///
        ///
        /// <para>
        /// For information about managing receipt rules, see the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the UpdateReceiptRule service method.</param>
        ///
        /// <returns>The response from the UpdateReceiptRule service method, as returned by SimpleEmailService.</returns>
        /// <exception cref="Amazon.SimpleEmail.Model.InvalidLambdaFunctionException">
        /// Indicates that the provided AWS Lambda function is invalid, or that Amazon SES could
        /// not execute the provided function, possibly due to permissions issues. For information
        /// about giving permissions, see the Amazon
        /// SES Developer Guide.
        /// </exception>
        /// <exception cref="Amazon.SimpleEmail.Model.InvalidS3ConfigurationException">
        /// Indicates that the provided Amazon S3 bucket or AWS KMS encryption key is invalid,
        /// or that Amazon SES could not publish to the bucket, possibly due to permissions issues.
        /// For information about giving permissions, see the Amazon
        /// SES Developer Guide.
        /// </exception>
        /// <exception cref="Amazon.SimpleEmail.Model.InvalidSnsTopicException">
        /// Indicates that the provided Amazon SNS topic is invalid, or that Amazon SES could
        /// not publish to the topic, possibly due to permissions issues. For information about
        /// giving permissions, see the Amazon
        /// SES Developer Guide.
        /// </exception>
        /// <exception cref="Amazon.SimpleEmail.Model.LimitExceededException">
        /// Indicates that a resource could not be created due to service limits. For a list of
        /// Amazon SES limits, see the Amazon
        /// SES Developer Guide.
        /// </exception>
        /// <exception cref="Amazon.SimpleEmail.Model.RuleDoesNotExistException">
        /// Indicates that the provided receipt rule does not exist.
        /// </exception>
        /// <exception cref="Amazon.SimpleEmail.Model.RuleSetDoesNotExistException">
        /// Indicates that the provided receipt rule set does not exist.
        /// </exception>
        public UpdateReceiptRuleResponse UpdateReceiptRule(UpdateReceiptRuleRequest request)
        {
            var marshaller = new UpdateReceiptRuleRequestMarshaller();
            var unmarshaller = UpdateReceiptRuleResponseUnmarshaller.Instance;

            return Invoke<UpdateReceiptRuleRequest,UpdateReceiptRuleResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the UpdateReceiptRule operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the UpdateReceiptRule operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<UpdateReceiptRuleResponse> UpdateReceiptRuleAsync(UpdateReceiptRuleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new UpdateReceiptRuleRequestMarshaller();
            var unmarshaller = UpdateReceiptRuleResponseUnmarshaller.Instance;

            return InvokeAsync<UpdateReceiptRuleRequest,UpdateReceiptRuleResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  VerifyDomainDkim

        ///
        /// Returns a set of DKIM tokens for a domain. DKIM tokens are character strings
        /// that represent your domain's identity. Using these tokens, you will need to create
        /// DNS CNAME records that point to DKIM public keys hosted by Amazon SES. Amazon Web
        /// Services will eventually detect that you have updated your DNS records; this detection
        /// process may take up to 72 hours. Upon successful detection, Amazon SES will be able
        /// to DKIM-sign email originating from that domain.
        ///
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <para>
        /// To enable or disable Easy DKIM signing for a domain, use the SetIdentityDkimEnabled
        /// action.
        /// </para>
        ///
        /// <para>
        /// For more information about creating DNS records using DKIM tokens, go to the Amazon
        /// SES Developer Guide.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the VerifyDomainDkim service method.</param>
        ///
        /// <returns>The response from the VerifyDomainDkim service method, as returned by SimpleEmailService.</returns>
        public VerifyDomainDkimResponse VerifyDomainDkim(VerifyDomainDkimRequest request)
        {
            var marshaller = new VerifyDomainDkimRequestMarshaller();
            var unmarshaller = VerifyDomainDkimResponseUnmarshaller.Instance;

            return Invoke<VerifyDomainDkimRequest,VerifyDomainDkimResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the VerifyDomainDkim operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the VerifyDomainDkim operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<VerifyDomainDkimResponse> VerifyDomainDkimAsync(VerifyDomainDkimRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new VerifyDomainDkimRequestMarshaller();
            var unmarshaller = VerifyDomainDkimResponseUnmarshaller.Instance;

            return InvokeAsync<VerifyDomainDkimRequest,VerifyDomainDkimResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  VerifyDomainIdentity

        ///
        /// Verifies a domain.
        ///
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the VerifyDomainIdentity service method.</param>
        ///
        /// <returns>The response from the VerifyDomainIdentity service method, as returned by SimpleEmailService.</returns>
        public VerifyDomainIdentityResponse VerifyDomainIdentity(VerifyDomainIdentityRequest request)
        {
            var marshaller = new VerifyDomainIdentityRequestMarshaller();
            var unmarshaller = VerifyDomainIdentityResponseUnmarshaller.Instance;

            return Invoke<VerifyDomainIdentityRequest,VerifyDomainIdentityResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the VerifyDomainIdentity operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the VerifyDomainIdentity operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<VerifyDomainIdentityResponse> VerifyDomainIdentityAsync(VerifyDomainIdentityRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new VerifyDomainIdentityRequestMarshaller();
            var unmarshaller = VerifyDomainIdentityResponseUnmarshaller.Instance;

            return InvokeAsync<VerifyDomainIdentityRequest,VerifyDomainIdentityResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  VerifyEmailAddress

        ///
        /// Verifies an email address. This action causes a confirmation email message to be sent
        /// to the specified address.
        ///
        ///  <important>The VerifyEmailAddress action is deprecated as of the May 15, 2012 release
        /// of Domain Verification. The VerifyEmailIdentity action is now preferred.</important>
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the VerifyEmailAddress service method.</param>
        ///
        /// <returns>The response from the VerifyEmailAddress service method, as returned by SimpleEmailService.</returns>
        public VerifyEmailAddressResponse VerifyEmailAddress(VerifyEmailAddressRequest request)
        {
            var marshaller = new VerifyEmailAddressRequestMarshaller();
            var unmarshaller = VerifyEmailAddressResponseUnmarshaller.Instance;

            return Invoke<VerifyEmailAddressRequest,VerifyEmailAddressResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the VerifyEmailAddress operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the VerifyEmailAddress operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<VerifyEmailAddressResponse> VerifyEmailAddressAsync(VerifyEmailAddressRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new VerifyEmailAddressRequestMarshaller();
            var unmarshaller = VerifyEmailAddressResponseUnmarshaller.Instance;

            return InvokeAsync<VerifyEmailAddressRequest,VerifyEmailAddressResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  VerifyEmailIdentity

        ///
        /// Verifies an email address. This action causes a confirmation email message to be sent
        /// to the specified address.
        ///
        ///
        /// <para>
        /// This action is throttled at one request per second.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the VerifyEmailIdentity service method.</param>
        ///
        /// <returns>The response from the VerifyEmailIdentity service method, as returned by SimpleEmailService.</returns>
        public VerifyEmailIdentityResponse VerifyEmailIdentity(VerifyEmailIdentityRequest request)
        {
            var marshaller = new VerifyEmailIdentityRequestMarshaller();
            var unmarshaller = VerifyEmailIdentityResponseUnmarshaller.Instance;

            return Invoke<VerifyEmailIdentityRequest,VerifyEmailIdentityResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the VerifyEmailIdentity operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the VerifyEmailIdentity operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<VerifyEmailIdentityResponse> VerifyEmailIdentityAsync(VerifyEmailIdentityRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new VerifyEmailIdentityRequestMarshaller();
            var unmarshaller = VerifyEmailIdentityResponseUnmarshaller.Instance;

            return InvokeAsync<VerifyEmailIdentityRequest,VerifyEmailIdentityResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

    }
}