/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include #include namespace Aws { namespace SES { /** * Amazon Simple Email Service

This document contains * reference information for the Amazon * Simple Email Service (Amazon SES) API, version 2010-12-01. This document is * best used in conjunction with the Amazon * SES Developer Guide.

For a list of Amazon SES endpoints to * use in service requests, see Regions * and Amazon SES in the Amazon * SES Developer Guide.

*/ class AWS_SES_API SESClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef SESClientConfiguration ClientConfigurationType; typedef SESEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ SESClient(const Aws::SES::SESClientConfiguration& clientConfiguration = Aws::SES::SESClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ SESClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::SES::SESClientConfiguration& clientConfiguration = Aws::SES::SESClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ SESClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::SES::SESClientConfiguration& clientConfiguration = Aws::SES::SESClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ SESClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ SESClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ SESClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~SESClient(); /** * Converts any request object to a presigned URL with the GET method, using region for the signer and a timeout of 15 minutes. */ Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const; /** *

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.

For information about setting up rule * sets, see the Amazon * SES Developer Guide.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::CloneReceiptRuleSetOutcome CloneReceiptRuleSet(const Model::CloneReceiptRuleSetRequest& request) const; /** * A Callable wrapper for CloneReceiptRuleSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CloneReceiptRuleSetOutcomeCallable CloneReceiptRuleSetCallable(const CloneReceiptRuleSetRequestT& request) const { return SubmitCallable(&SESClient::CloneReceiptRuleSet, request); } /** * An Async wrapper for CloneReceiptRuleSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CloneReceiptRuleSetAsync(const CloneReceiptRuleSetRequestT& request, const CloneReceiptRuleSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::CloneReceiptRuleSet, request, handler, context); } /** *

Creates a configuration set.

Configuration sets enable you to publish * email sending events. For information about using configuration sets, see the Amazon * SES Developer Guide.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::CreateConfigurationSetOutcome CreateConfigurationSet(const Model::CreateConfigurationSetRequest& request) const; /** * A Callable wrapper for CreateConfigurationSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateConfigurationSetOutcomeCallable CreateConfigurationSetCallable(const CreateConfigurationSetRequestT& request) const { return SubmitCallable(&SESClient::CreateConfigurationSet, request); } /** * An Async wrapper for CreateConfigurationSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateConfigurationSetAsync(const CreateConfigurationSetRequestT& request, const CreateConfigurationSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::CreateConfigurationSet, request, handler, context); } /** *

Creates a configuration set event destination.

When you create * or update an event destination, you must provide one, and only one, destination. * The destination can be CloudWatch, Amazon Kinesis Firehose, or Amazon Simple * Notification Service (Amazon SNS).

An event destination is the * AWS service to which Amazon SES publishes the email sending events associated * with a configuration set. For information about using configuration sets, see * the Amazon * SES Developer Guide.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::CreateConfigurationSetEventDestinationOutcome CreateConfigurationSetEventDestination(const Model::CreateConfigurationSetEventDestinationRequest& request) const; /** * A Callable wrapper for CreateConfigurationSetEventDestination that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateConfigurationSetEventDestinationOutcomeCallable CreateConfigurationSetEventDestinationCallable(const CreateConfigurationSetEventDestinationRequestT& request) const { return SubmitCallable(&SESClient::CreateConfigurationSetEventDestination, request); } /** * An Async wrapper for CreateConfigurationSetEventDestination that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateConfigurationSetEventDestinationAsync(const CreateConfigurationSetEventDestinationRequestT& request, const CreateConfigurationSetEventDestinationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::CreateConfigurationSetEventDestination, request, handler, context); } /** *

Creates an association between a configuration set and a custom domain for * open and click event tracking.

By default, images and links used for * tracking open and click events are hosted on domains operated by Amazon SES. You * can configure a subdomain of your own to handle these events. For information * about using custom domains, see the Amazon * SES Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateConfigurationSetTrackingOptionsOutcome CreateConfigurationSetTrackingOptions(const Model::CreateConfigurationSetTrackingOptionsRequest& request) const; /** * A Callable wrapper for CreateConfigurationSetTrackingOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateConfigurationSetTrackingOptionsOutcomeCallable CreateConfigurationSetTrackingOptionsCallable(const CreateConfigurationSetTrackingOptionsRequestT& request) const { return SubmitCallable(&SESClient::CreateConfigurationSetTrackingOptions, request); } /** * An Async wrapper for CreateConfigurationSetTrackingOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateConfigurationSetTrackingOptionsAsync(const CreateConfigurationSetTrackingOptionsRequestT& request, const CreateConfigurationSetTrackingOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::CreateConfigurationSetTrackingOptions, request, handler, context); } /** *

Creates a new custom verification email template.

For more information * about custom verification email templates, see Using * Custom Verification Email Templates in the Amazon SES Developer * Guide.

You can execute this operation no more than once per * second.

See Also:

AWS * API Reference

*/ virtual Model::CreateCustomVerificationEmailTemplateOutcome CreateCustomVerificationEmailTemplate(const Model::CreateCustomVerificationEmailTemplateRequest& request) const; /** * A Callable wrapper for CreateCustomVerificationEmailTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCustomVerificationEmailTemplateOutcomeCallable CreateCustomVerificationEmailTemplateCallable(const CreateCustomVerificationEmailTemplateRequestT& request) const { return SubmitCallable(&SESClient::CreateCustomVerificationEmailTemplate, request); } /** * An Async wrapper for CreateCustomVerificationEmailTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCustomVerificationEmailTemplateAsync(const CreateCustomVerificationEmailTemplateRequestT& request, const CreateCustomVerificationEmailTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::CreateCustomVerificationEmailTemplate, request, handler, context); } /** *

Creates a new IP address filter.

For information about setting up IP * address filters, see the Amazon * SES Developer Guide.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::CreateReceiptFilterOutcome CreateReceiptFilter(const Model::CreateReceiptFilterRequest& request) const; /** * A Callable wrapper for CreateReceiptFilter that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateReceiptFilterOutcomeCallable CreateReceiptFilterCallable(const CreateReceiptFilterRequestT& request) const { return SubmitCallable(&SESClient::CreateReceiptFilter, request); } /** * An Async wrapper for CreateReceiptFilter that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateReceiptFilterAsync(const CreateReceiptFilterRequestT& request, const CreateReceiptFilterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::CreateReceiptFilter, request, handler, context); } /** *

Creates a receipt rule.

For information about setting up receipt * rules, see the Amazon * SES Developer Guide.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::CreateReceiptRuleOutcome CreateReceiptRule(const Model::CreateReceiptRuleRequest& request) const; /** * A Callable wrapper for CreateReceiptRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateReceiptRuleOutcomeCallable CreateReceiptRuleCallable(const CreateReceiptRuleRequestT& request) const { return SubmitCallable(&SESClient::CreateReceiptRule, request); } /** * An Async wrapper for CreateReceiptRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateReceiptRuleAsync(const CreateReceiptRuleRequestT& request, const CreateReceiptRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::CreateReceiptRule, request, handler, context); } /** *

Creates an empty receipt rule set.

For information about setting up * receipt rule sets, see the Amazon * SES Developer Guide.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::CreateReceiptRuleSetOutcome CreateReceiptRuleSet(const Model::CreateReceiptRuleSetRequest& request) const; /** * A Callable wrapper for CreateReceiptRuleSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateReceiptRuleSetOutcomeCallable CreateReceiptRuleSetCallable(const CreateReceiptRuleSetRequestT& request) const { return SubmitCallable(&SESClient::CreateReceiptRuleSet, request); } /** * An Async wrapper for CreateReceiptRuleSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateReceiptRuleSetAsync(const CreateReceiptRuleSetRequestT& request, const CreateReceiptRuleSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::CreateReceiptRuleSet, request, handler, context); } /** *

Creates an email template. Email templates enable you to send personalized * email to one or more destinations in a single API operation. For more * information, see the Amazon * SES Developer Guide.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::CreateTemplateOutcome CreateTemplate(const Model::CreateTemplateRequest& request) const; /** * A Callable wrapper for CreateTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTemplateOutcomeCallable CreateTemplateCallable(const CreateTemplateRequestT& request) const { return SubmitCallable(&SESClient::CreateTemplate, request); } /** * An Async wrapper for CreateTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTemplateAsync(const CreateTemplateRequestT& request, const CreateTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::CreateTemplate, request, handler, context); } /** *

Deletes a configuration set. Configuration sets enable you to publish email * sending events. For information about using configuration sets, see the Amazon * SES Developer Guide.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::DeleteConfigurationSetOutcome DeleteConfigurationSet(const Model::DeleteConfigurationSetRequest& request) const; /** * A Callable wrapper for DeleteConfigurationSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteConfigurationSetOutcomeCallable DeleteConfigurationSetCallable(const DeleteConfigurationSetRequestT& request) const { return SubmitCallable(&SESClient::DeleteConfigurationSet, request); } /** * An Async wrapper for DeleteConfigurationSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteConfigurationSetAsync(const DeleteConfigurationSetRequestT& request, const DeleteConfigurationSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::DeleteConfigurationSet, request, handler, context); } /** *

Deletes a configuration set event destination. Configuration set event * destinations are associated with configuration sets, which enable you to publish * email sending events. For information about using configuration sets, see the Amazon * SES Developer Guide.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::DeleteConfigurationSetEventDestinationOutcome DeleteConfigurationSetEventDestination(const Model::DeleteConfigurationSetEventDestinationRequest& request) const; /** * A Callable wrapper for DeleteConfigurationSetEventDestination that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteConfigurationSetEventDestinationOutcomeCallable DeleteConfigurationSetEventDestinationCallable(const DeleteConfigurationSetEventDestinationRequestT& request) const { return SubmitCallable(&SESClient::DeleteConfigurationSetEventDestination, request); } /** * An Async wrapper for DeleteConfigurationSetEventDestination that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteConfigurationSetEventDestinationAsync(const DeleteConfigurationSetEventDestinationRequestT& request, const DeleteConfigurationSetEventDestinationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::DeleteConfigurationSetEventDestination, request, handler, context); } /** *

Deletes an association between a configuration set and a custom domain for * open and click event tracking.

By default, images and links used for * tracking open and click events are hosted on domains operated by Amazon SES. You * can configure a subdomain of your own to handle these events. For information * about using custom domains, see the Amazon * SES Developer Guide.

Deleting this kind of association will * result in emails sent using the specified configuration set to capture open and * click events using the standard, Amazon SES-operated domains.

*

See Also:

AWS * API Reference

*/ virtual Model::DeleteConfigurationSetTrackingOptionsOutcome DeleteConfigurationSetTrackingOptions(const Model::DeleteConfigurationSetTrackingOptionsRequest& request) const; /** * A Callable wrapper for DeleteConfigurationSetTrackingOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteConfigurationSetTrackingOptionsOutcomeCallable DeleteConfigurationSetTrackingOptionsCallable(const DeleteConfigurationSetTrackingOptionsRequestT& request) const { return SubmitCallable(&SESClient::DeleteConfigurationSetTrackingOptions, request); } /** * An Async wrapper for DeleteConfigurationSetTrackingOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteConfigurationSetTrackingOptionsAsync(const DeleteConfigurationSetTrackingOptionsRequestT& request, const DeleteConfigurationSetTrackingOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::DeleteConfigurationSetTrackingOptions, request, handler, context); } /** *

Deletes an existing custom verification email template.

For more * information about custom verification email templates, see Using * Custom Verification Email Templates in the Amazon SES Developer * Guide.

You can execute this operation no more than once per * second.

See Also:

AWS * API Reference

*/ virtual Model::DeleteCustomVerificationEmailTemplateOutcome DeleteCustomVerificationEmailTemplate(const Model::DeleteCustomVerificationEmailTemplateRequest& request) const; /** * A Callable wrapper for DeleteCustomVerificationEmailTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCustomVerificationEmailTemplateOutcomeCallable DeleteCustomVerificationEmailTemplateCallable(const DeleteCustomVerificationEmailTemplateRequestT& request) const { return SubmitCallable(&SESClient::DeleteCustomVerificationEmailTemplate, request); } /** * An Async wrapper for DeleteCustomVerificationEmailTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCustomVerificationEmailTemplateAsync(const DeleteCustomVerificationEmailTemplateRequestT& request, const DeleteCustomVerificationEmailTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::DeleteCustomVerificationEmailTemplate, request, handler, context); } /** *

Deletes the specified identity (an email address or a domain) from the list * of verified identities.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::DeleteIdentityOutcome DeleteIdentity(const Model::DeleteIdentityRequest& request) const; /** * A Callable wrapper for DeleteIdentity that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteIdentityOutcomeCallable DeleteIdentityCallable(const DeleteIdentityRequestT& request) const { return SubmitCallable(&SESClient::DeleteIdentity, request); } /** * An Async wrapper for DeleteIdentity that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteIdentityAsync(const DeleteIdentityRequestT& request, const DeleteIdentityResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::DeleteIdentity, request, handler, context); } /** *

Deletes the specified sending authorization policy for the given identity (an * email address or a domain). This API returns successfully even if a policy with * the specified name does not exist.

This API is for the identity * owner only. If you have not verified the identity, this API will return an * error.

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.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::DeleteIdentityPolicyOutcome DeleteIdentityPolicy(const Model::DeleteIdentityPolicyRequest& request) const; /** * A Callable wrapper for DeleteIdentityPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteIdentityPolicyOutcomeCallable DeleteIdentityPolicyCallable(const DeleteIdentityPolicyRequestT& request) const { return SubmitCallable(&SESClient::DeleteIdentityPolicy, request); } /** * An Async wrapper for DeleteIdentityPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteIdentityPolicyAsync(const DeleteIdentityPolicyRequestT& request, const DeleteIdentityPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::DeleteIdentityPolicy, request, handler, context); } /** *

Deletes the specified IP address filter.

For information about * managing IP address filters, see the Amazon * SES Developer Guide.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::DeleteReceiptFilterOutcome DeleteReceiptFilter(const Model::DeleteReceiptFilterRequest& request) const; /** * A Callable wrapper for DeleteReceiptFilter that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteReceiptFilterOutcomeCallable DeleteReceiptFilterCallable(const DeleteReceiptFilterRequestT& request) const { return SubmitCallable(&SESClient::DeleteReceiptFilter, request); } /** * An Async wrapper for DeleteReceiptFilter that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteReceiptFilterAsync(const DeleteReceiptFilterRequestT& request, const DeleteReceiptFilterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::DeleteReceiptFilter, request, handler, context); } /** *

Deletes the specified receipt rule.

For information about managing * receipt rules, see the Amazon * SES Developer Guide.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::DeleteReceiptRuleOutcome DeleteReceiptRule(const Model::DeleteReceiptRuleRequest& request) const; /** * A Callable wrapper for DeleteReceiptRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteReceiptRuleOutcomeCallable DeleteReceiptRuleCallable(const DeleteReceiptRuleRequestT& request) const { return SubmitCallable(&SESClient::DeleteReceiptRule, request); } /** * An Async wrapper for DeleteReceiptRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteReceiptRuleAsync(const DeleteReceiptRuleRequestT& request, const DeleteReceiptRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::DeleteReceiptRule, request, handler, context); } /** *

Deletes the specified receipt rule set and all of the receipt rules it * contains.

The currently active rule set cannot be deleted.

*

For information about managing receipt rule sets, see the Amazon * SES Developer Guide.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::DeleteReceiptRuleSetOutcome DeleteReceiptRuleSet(const Model::DeleteReceiptRuleSetRequest& request) const; /** * A Callable wrapper for DeleteReceiptRuleSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteReceiptRuleSetOutcomeCallable DeleteReceiptRuleSetCallable(const DeleteReceiptRuleSetRequestT& request) const { return SubmitCallable(&SESClient::DeleteReceiptRuleSet, request); } /** * An Async wrapper for DeleteReceiptRuleSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteReceiptRuleSetAsync(const DeleteReceiptRuleSetRequestT& request, const DeleteReceiptRuleSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::DeleteReceiptRuleSet, request, handler, context); } /** *

Deletes an email template.

You can execute this operation no more than * once per second.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTemplateOutcome DeleteTemplate(const Model::DeleteTemplateRequest& request) const; /** * A Callable wrapper for DeleteTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTemplateOutcomeCallable DeleteTemplateCallable(const DeleteTemplateRequestT& request) const { return SubmitCallable(&SESClient::DeleteTemplate, request); } /** * An Async wrapper for DeleteTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTemplateAsync(const DeleteTemplateRequestT& request, const DeleteTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::DeleteTemplate, request, handler, context); } /** *

Deprecated. Use the DeleteIdentity operation to delete email * addresses and domains.

See Also:

AWS * API Reference

*/ virtual Model::DeleteVerifiedEmailAddressOutcome DeleteVerifiedEmailAddress(const Model::DeleteVerifiedEmailAddressRequest& request) const; /** * A Callable wrapper for DeleteVerifiedEmailAddress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVerifiedEmailAddressOutcomeCallable DeleteVerifiedEmailAddressCallable(const DeleteVerifiedEmailAddressRequestT& request) const { return SubmitCallable(&SESClient::DeleteVerifiedEmailAddress, request); } /** * An Async wrapper for DeleteVerifiedEmailAddress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVerifiedEmailAddressAsync(const DeleteVerifiedEmailAddressRequestT& request, const DeleteVerifiedEmailAddressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::DeleteVerifiedEmailAddress, request, handler, context); } /** *

Returns the metadata and receipt rules for the receipt rule set that is * currently active.

For information about setting up receipt rule sets, see * the Amazon * SES Developer Guide.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::DescribeActiveReceiptRuleSetOutcome DescribeActiveReceiptRuleSet(const Model::DescribeActiveReceiptRuleSetRequest& request) const; /** * A Callable wrapper for DescribeActiveReceiptRuleSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeActiveReceiptRuleSetOutcomeCallable DescribeActiveReceiptRuleSetCallable(const DescribeActiveReceiptRuleSetRequestT& request) const { return SubmitCallable(&SESClient::DescribeActiveReceiptRuleSet, request); } /** * An Async wrapper for DescribeActiveReceiptRuleSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeActiveReceiptRuleSetAsync(const DescribeActiveReceiptRuleSetRequestT& request, const DescribeActiveReceiptRuleSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::DescribeActiveReceiptRuleSet, request, handler, context); } /** *

Returns the details of the specified configuration set. For information about * using configuration sets, see the Amazon * SES Developer Guide.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::DescribeConfigurationSetOutcome DescribeConfigurationSet(const Model::DescribeConfigurationSetRequest& request) const; /** * A Callable wrapper for DescribeConfigurationSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeConfigurationSetOutcomeCallable DescribeConfigurationSetCallable(const DescribeConfigurationSetRequestT& request) const { return SubmitCallable(&SESClient::DescribeConfigurationSet, request); } /** * An Async wrapper for DescribeConfigurationSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeConfigurationSetAsync(const DescribeConfigurationSetRequestT& request, const DescribeConfigurationSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::DescribeConfigurationSet, request, handler, context); } /** *

Returns the details of the specified receipt rule.

For information * about setting up receipt rules, see the Amazon * SES Developer Guide.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::DescribeReceiptRuleOutcome DescribeReceiptRule(const Model::DescribeReceiptRuleRequest& request) const; /** * A Callable wrapper for DescribeReceiptRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeReceiptRuleOutcomeCallable DescribeReceiptRuleCallable(const DescribeReceiptRuleRequestT& request) const { return SubmitCallable(&SESClient::DescribeReceiptRule, request); } /** * An Async wrapper for DescribeReceiptRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeReceiptRuleAsync(const DescribeReceiptRuleRequestT& request, const DescribeReceiptRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::DescribeReceiptRule, request, handler, context); } /** *

Returns the details of the specified receipt rule set.

For information * about managing receipt rule sets, see the Amazon * SES Developer Guide.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::DescribeReceiptRuleSetOutcome DescribeReceiptRuleSet(const Model::DescribeReceiptRuleSetRequest& request) const; /** * A Callable wrapper for DescribeReceiptRuleSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeReceiptRuleSetOutcomeCallable DescribeReceiptRuleSetCallable(const DescribeReceiptRuleSetRequestT& request) const { return SubmitCallable(&SESClient::DescribeReceiptRuleSet, request); } /** * An Async wrapper for DescribeReceiptRuleSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeReceiptRuleSetAsync(const DescribeReceiptRuleSetRequestT& request, const DescribeReceiptRuleSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::DescribeReceiptRuleSet, request, handler, context); } /** *

Returns the email sending status of the Amazon SES account for the current * region.

You can execute this operation no more than once per * second.

See Also:

AWS * API Reference

*/ virtual Model::GetAccountSendingEnabledOutcome GetAccountSendingEnabled(const Model::GetAccountSendingEnabledRequest& request) const; /** * A Callable wrapper for GetAccountSendingEnabled that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAccountSendingEnabledOutcomeCallable GetAccountSendingEnabledCallable(const GetAccountSendingEnabledRequestT& request) const { return SubmitCallable(&SESClient::GetAccountSendingEnabled, request); } /** * An Async wrapper for GetAccountSendingEnabled that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAccountSendingEnabledAsync(const GetAccountSendingEnabledRequestT& request, const GetAccountSendingEnabledResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::GetAccountSendingEnabled, request, handler, context); } /** *

Returns the custom email verification template for the template name you * specify.

For more information about custom verification email templates, * see Using * Custom Verification Email Templates in the Amazon SES Developer * Guide.

You can execute this operation no more than once per * second.

See Also:

AWS * API Reference

*/ virtual Model::GetCustomVerificationEmailTemplateOutcome GetCustomVerificationEmailTemplate(const Model::GetCustomVerificationEmailTemplateRequest& request) const; /** * A Callable wrapper for GetCustomVerificationEmailTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCustomVerificationEmailTemplateOutcomeCallable GetCustomVerificationEmailTemplateCallable(const GetCustomVerificationEmailTemplateRequestT& request) const { return SubmitCallable(&SESClient::GetCustomVerificationEmailTemplate, request); } /** * An Async wrapper for GetCustomVerificationEmailTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCustomVerificationEmailTemplateAsync(const GetCustomVerificationEmailTemplateRequestT& request, const GetCustomVerificationEmailTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::GetCustomVerificationEmailTemplate, request, handler, context); } /** *

Returns the current status of Easy DKIM signing for an entity. For domain * name identities, this operation 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.

This operation takes a list of * identities as input and returns the following information for each:

    *

  • 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.

This operation is throttled at one * request per second and can only get DKIM attributes for up to 100 identities at * a time.

For more information about creating DNS records using DKIM * tokens, go to the Amazon * SES Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::GetIdentityDkimAttributesOutcome GetIdentityDkimAttributes(const Model::GetIdentityDkimAttributesRequest& request) const; /** * A Callable wrapper for GetIdentityDkimAttributes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetIdentityDkimAttributesOutcomeCallable GetIdentityDkimAttributesCallable(const GetIdentityDkimAttributesRequestT& request) const { return SubmitCallable(&SESClient::GetIdentityDkimAttributes, request); } /** * An Async wrapper for GetIdentityDkimAttributes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetIdentityDkimAttributesAsync(const GetIdentityDkimAttributesRequestT& request, const GetIdentityDkimAttributesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::GetIdentityDkimAttributes, request, handler, context); } /** *

Returns the custom MAIL FROM attributes for a list of identities (email * addresses : domains).

This operation is throttled at one request per * second and can only get custom MAIL FROM attributes for up to 100 identities at * a time.

See Also:

AWS * API Reference

*/ virtual Model::GetIdentityMailFromDomainAttributesOutcome GetIdentityMailFromDomainAttributes(const Model::GetIdentityMailFromDomainAttributesRequest& request) const; /** * A Callable wrapper for GetIdentityMailFromDomainAttributes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetIdentityMailFromDomainAttributesOutcomeCallable GetIdentityMailFromDomainAttributesCallable(const GetIdentityMailFromDomainAttributesRequestT& request) const { return SubmitCallable(&SESClient::GetIdentityMailFromDomainAttributes, request); } /** * An Async wrapper for GetIdentityMailFromDomainAttributes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetIdentityMailFromDomainAttributesAsync(const GetIdentityMailFromDomainAttributesRequestT& request, const GetIdentityMailFromDomainAttributesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::GetIdentityMailFromDomainAttributes, request, handler, context); } /** *

Given a list of verified identities (email addresses and/or domains), returns * a structure describing identity notification attributes.

This operation * is throttled at one request per second and can only get notification attributes * for up to 100 identities at a time.

For more information about using * notifications with Amazon SES, see the Amazon * SES Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::GetIdentityNotificationAttributesOutcome GetIdentityNotificationAttributes(const Model::GetIdentityNotificationAttributesRequest& request) const; /** * A Callable wrapper for GetIdentityNotificationAttributes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetIdentityNotificationAttributesOutcomeCallable GetIdentityNotificationAttributesCallable(const GetIdentityNotificationAttributesRequestT& request) const { return SubmitCallable(&SESClient::GetIdentityNotificationAttributes, request); } /** * An Async wrapper for GetIdentityNotificationAttributes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetIdentityNotificationAttributesAsync(const GetIdentityNotificationAttributesRequestT& request, const GetIdentityNotificationAttributesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::GetIdentityNotificationAttributes, request, handler, context); } /** *

Returns the requested sending authorization policies for the given identity * (an email address or a 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.

This API is for the identity owner only. If you have not * verified the identity, this API will return an error.

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.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::GetIdentityPoliciesOutcome GetIdentityPolicies(const Model::GetIdentityPoliciesRequest& request) const; /** * A Callable wrapper for GetIdentityPolicies that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetIdentityPoliciesOutcomeCallable GetIdentityPoliciesCallable(const GetIdentityPoliciesRequestT& request) const { return SubmitCallable(&SESClient::GetIdentityPolicies, request); } /** * An Async wrapper for GetIdentityPolicies that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetIdentityPoliciesAsync(const GetIdentityPoliciesRequestT& request, const GetIdentityPoliciesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::GetIdentityPolicies, request, handler, context); } /** *

Given a list of identities (email addresses and/or domains), returns the * verification status and (for domain identities) the verification token for each * identity.

The verification status of an email address is "Pending" until * the email address owner clicks the link within the verification email that * Amazon SES sent to that address. If the email address owner clicks the link * within 24 hours, the verification status of the email address changes to * "Success". If the link is not clicked within 24 hours, the verification status * changes to "Failed." In that case, if you still want to verify the email * address, you must restart the verification process from the beginning.

*

For domain identities, the domain's verification status is "Pending" as * Amazon SES searches for the required TXT record in the DNS settings of the * domain. When Amazon SES detects the record, the domain's verification status * changes to "Success". If Amazon SES is unable to detect the record within 72 * hours, the domain's verification status changes to "Failed." In that case, if * you still want to verify the domain, you must restart the verification process * from the beginning.

This operation is throttled at one request per second * and can only get verification attributes for up to 100 identities at a * time.

See Also:

AWS * API Reference

*/ virtual Model::GetIdentityVerificationAttributesOutcome GetIdentityVerificationAttributes(const Model::GetIdentityVerificationAttributesRequest& request) const; /** * A Callable wrapper for GetIdentityVerificationAttributes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetIdentityVerificationAttributesOutcomeCallable GetIdentityVerificationAttributesCallable(const GetIdentityVerificationAttributesRequestT& request) const { return SubmitCallable(&SESClient::GetIdentityVerificationAttributes, request); } /** * An Async wrapper for GetIdentityVerificationAttributes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetIdentityVerificationAttributesAsync(const GetIdentityVerificationAttributesRequestT& request, const GetIdentityVerificationAttributesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::GetIdentityVerificationAttributes, request, handler, context); } /** *

Provides the sending limits for the Amazon SES account.

You can * execute this operation no more than once per second.

See Also:

* AWS * API Reference

*/ virtual Model::GetSendQuotaOutcome GetSendQuota(const Model::GetSendQuotaRequest& request) const; /** * A Callable wrapper for GetSendQuota that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetSendQuotaOutcomeCallable GetSendQuotaCallable(const GetSendQuotaRequestT& request) const { return SubmitCallable(&SESClient::GetSendQuota, request); } /** * An Async wrapper for GetSendQuota that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetSendQuotaAsync(const GetSendQuotaRequestT& request, const GetSendQuotaResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::GetSendQuota, request, handler, context); } /** *

Provides sending statistics for the current AWS Region. The result is a list * of data points, representing the last two weeks of sending activity. Each data * point in the list contains statistics for a 15-minute period of time.

You * can execute this operation no more than once per second.

See * Also:

AWS * API Reference

*/ virtual Model::GetSendStatisticsOutcome GetSendStatistics(const Model::GetSendStatisticsRequest& request) const; /** * A Callable wrapper for GetSendStatistics that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetSendStatisticsOutcomeCallable GetSendStatisticsCallable(const GetSendStatisticsRequestT& request) const { return SubmitCallable(&SESClient::GetSendStatistics, request); } /** * An Async wrapper for GetSendStatistics that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetSendStatisticsAsync(const GetSendStatisticsRequestT& request, const GetSendStatisticsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::GetSendStatistics, request, handler, context); } /** *

Displays the template object (which includes the Subject line, HTML part and * text part) for the template you specify.

You can execute this operation * no more than once per second.

See Also:

AWS * API Reference

*/ virtual Model::GetTemplateOutcome GetTemplate(const Model::GetTemplateRequest& request) const; /** * A Callable wrapper for GetTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetTemplateOutcomeCallable GetTemplateCallable(const GetTemplateRequestT& request) const { return SubmitCallable(&SESClient::GetTemplate, request); } /** * An Async wrapper for GetTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetTemplateAsync(const GetTemplateRequestT& request, const GetTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::GetTemplate, request, handler, context); } /** *

Provides a list of the configuration sets associated with your Amazon SES * account in the current AWS Region. For information about using configuration * sets, see Monitoring * Your Amazon SES Sending Activity in the Amazon SES Developer Guide. *

You can execute this operation no more than once per second. This * operation will return up to 1,000 configuration sets each time it is run. If * your Amazon SES account has more than 1,000 configuration sets, this operation * will also return a NextToken element. You can then execute the * ListConfigurationSets operation again, passing the * NextToken parameter and the value of the NextToken element to * retrieve additional results.

See Also:

AWS * API Reference

*/ virtual Model::ListConfigurationSetsOutcome ListConfigurationSets(const Model::ListConfigurationSetsRequest& request) const; /** * A Callable wrapper for ListConfigurationSets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListConfigurationSetsOutcomeCallable ListConfigurationSetsCallable(const ListConfigurationSetsRequestT& request) const { return SubmitCallable(&SESClient::ListConfigurationSets, request); } /** * An Async wrapper for ListConfigurationSets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListConfigurationSetsAsync(const ListConfigurationSetsRequestT& request, const ListConfigurationSetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::ListConfigurationSets, request, handler, context); } /** *

Lists the existing custom verification email templates for your account in * the current AWS Region.

For more information about custom verification * email templates, see Using * Custom Verification Email Templates in the Amazon SES Developer * Guide.

You can execute this operation no more than once per * second.

See Also:

AWS * API Reference

*/ virtual Model::ListCustomVerificationEmailTemplatesOutcome ListCustomVerificationEmailTemplates(const Model::ListCustomVerificationEmailTemplatesRequest& request) const; /** * A Callable wrapper for ListCustomVerificationEmailTemplates that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCustomVerificationEmailTemplatesOutcomeCallable ListCustomVerificationEmailTemplatesCallable(const ListCustomVerificationEmailTemplatesRequestT& request) const { return SubmitCallable(&SESClient::ListCustomVerificationEmailTemplates, request); } /** * An Async wrapper for ListCustomVerificationEmailTemplates that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCustomVerificationEmailTemplatesAsync(const ListCustomVerificationEmailTemplatesRequestT& request, const ListCustomVerificationEmailTemplatesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::ListCustomVerificationEmailTemplates, request, handler, context); } /** *

Returns a list containing all of the identities (email addresses and domains) * for your AWS account in the current AWS Region, regardless of verification * status.

You can execute this operation no more than once per * second.

See Also:

AWS * API Reference

*/ virtual Model::ListIdentitiesOutcome ListIdentities(const Model::ListIdentitiesRequest& request) const; /** * A Callable wrapper for ListIdentities that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListIdentitiesOutcomeCallable ListIdentitiesCallable(const ListIdentitiesRequestT& request) const { return SubmitCallable(&SESClient::ListIdentities, request); } /** * An Async wrapper for ListIdentities that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListIdentitiesAsync(const ListIdentitiesRequestT& request, const ListIdentitiesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::ListIdentities, request, handler, context); } /** *

Returns a list of sending authorization policies that are attached to the * given identity (an email address or a domain). This API returns only a list. If * you want the actual policy content, you can use * GetIdentityPolicies.

This API is for the identity * owner only. If you have not verified the identity, this API will return an * error.

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.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::ListIdentityPoliciesOutcome ListIdentityPolicies(const Model::ListIdentityPoliciesRequest& request) const; /** * A Callable wrapper for ListIdentityPolicies that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListIdentityPoliciesOutcomeCallable ListIdentityPoliciesCallable(const ListIdentityPoliciesRequestT& request) const { return SubmitCallable(&SESClient::ListIdentityPolicies, request); } /** * An Async wrapper for ListIdentityPolicies that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListIdentityPoliciesAsync(const ListIdentityPoliciesRequestT& request, const ListIdentityPoliciesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::ListIdentityPolicies, request, handler, context); } /** *

Lists the IP address filters associated with your AWS account in the current * AWS Region.

For information about managing IP address filters, see the Amazon * SES Developer Guide.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::ListReceiptFiltersOutcome ListReceiptFilters(const Model::ListReceiptFiltersRequest& request) const; /** * A Callable wrapper for ListReceiptFilters that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListReceiptFiltersOutcomeCallable ListReceiptFiltersCallable(const ListReceiptFiltersRequestT& request) const { return SubmitCallable(&SESClient::ListReceiptFilters, request); } /** * An Async wrapper for ListReceiptFilters that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListReceiptFiltersAsync(const ListReceiptFiltersRequestT& request, const ListReceiptFiltersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::ListReceiptFilters, request, handler, context); } /** *

Lists the receipt rule sets that exist under your AWS account in the current * AWS Region. 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.

For * information about managing receipt rule sets, see the Amazon * SES Developer Guide.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::ListReceiptRuleSetsOutcome ListReceiptRuleSets(const Model::ListReceiptRuleSetsRequest& request) const; /** * A Callable wrapper for ListReceiptRuleSets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListReceiptRuleSetsOutcomeCallable ListReceiptRuleSetsCallable(const ListReceiptRuleSetsRequestT& request) const { return SubmitCallable(&SESClient::ListReceiptRuleSets, request); } /** * An Async wrapper for ListReceiptRuleSets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListReceiptRuleSetsAsync(const ListReceiptRuleSetsRequestT& request, const ListReceiptRuleSetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::ListReceiptRuleSets, request, handler, context); } /** *

Lists the email templates present in your Amazon SES account in the current * AWS Region.

You can execute this operation no more than once per * second.

See Also:

AWS * API Reference

*/ virtual Model::ListTemplatesOutcome ListTemplates(const Model::ListTemplatesRequest& request) const; /** * A Callable wrapper for ListTemplates that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTemplatesOutcomeCallable ListTemplatesCallable(const ListTemplatesRequestT& request) const { return SubmitCallable(&SESClient::ListTemplates, request); } /** * An Async wrapper for ListTemplates that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTemplatesAsync(const ListTemplatesRequestT& request, const ListTemplatesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::ListTemplates, request, handler, context); } /** *

Deprecated. Use the ListIdentities operation to list the email * addresses and domains associated with your account.

See Also:

* AWS * API Reference

*/ virtual Model::ListVerifiedEmailAddressesOutcome ListVerifiedEmailAddresses(const Model::ListVerifiedEmailAddressesRequest& request) const; /** * A Callable wrapper for ListVerifiedEmailAddresses that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListVerifiedEmailAddressesOutcomeCallable ListVerifiedEmailAddressesCallable(const ListVerifiedEmailAddressesRequestT& request) const { return SubmitCallable(&SESClient::ListVerifiedEmailAddresses, request); } /** * An Async wrapper for ListVerifiedEmailAddresses that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListVerifiedEmailAddressesAsync(const ListVerifiedEmailAddressesRequestT& request, const ListVerifiedEmailAddressesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::ListVerifiedEmailAddresses, request, handler, context); } /** *

Adds or updates the delivery options for a configuration set.

See * Also:

AWS * API Reference

*/ virtual Model::PutConfigurationSetDeliveryOptionsOutcome PutConfigurationSetDeliveryOptions(const Model::PutConfigurationSetDeliveryOptionsRequest& request) const; /** * A Callable wrapper for PutConfigurationSetDeliveryOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutConfigurationSetDeliveryOptionsOutcomeCallable PutConfigurationSetDeliveryOptionsCallable(const PutConfigurationSetDeliveryOptionsRequestT& request) const { return SubmitCallable(&SESClient::PutConfigurationSetDeliveryOptions, request); } /** * An Async wrapper for PutConfigurationSetDeliveryOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutConfigurationSetDeliveryOptionsAsync(const PutConfigurationSetDeliveryOptionsRequestT& request, const PutConfigurationSetDeliveryOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::PutConfigurationSetDeliveryOptions, request, handler, context); } /** *

Adds or updates a sending authorization policy for the specified identity (an * email address or a domain).

This API is for the identity owner * only. If you have not verified the identity, this API will return an error.

*

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.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::PutIdentityPolicyOutcome PutIdentityPolicy(const Model::PutIdentityPolicyRequest& request) const; /** * A Callable wrapper for PutIdentityPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutIdentityPolicyOutcomeCallable PutIdentityPolicyCallable(const PutIdentityPolicyRequestT& request) const { return SubmitCallable(&SESClient::PutIdentityPolicy, request); } /** * An Async wrapper for PutIdentityPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutIdentityPolicyAsync(const PutIdentityPolicyRequestT& request, const PutIdentityPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::PutIdentityPolicy, request, handler, context); } /** *

Reorders the receipt rules within a receipt rule set.

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.

For information about managing receipt rule sets, see * the Amazon * SES Developer Guide.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::ReorderReceiptRuleSetOutcome ReorderReceiptRuleSet(const Model::ReorderReceiptRuleSetRequest& request) const; /** * A Callable wrapper for ReorderReceiptRuleSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ReorderReceiptRuleSetOutcomeCallable ReorderReceiptRuleSetCallable(const ReorderReceiptRuleSetRequestT& request) const { return SubmitCallable(&SESClient::ReorderReceiptRuleSet, request); } /** * An Async wrapper for ReorderReceiptRuleSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ReorderReceiptRuleSetAsync(const ReorderReceiptRuleSetRequestT& request, const ReorderReceiptRuleSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::ReorderReceiptRuleSet, request, handler, context); } /** *

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.

You cannot use this API to send generic bounces * for mail that was not received by Amazon SES.

For information * about receiving email through Amazon SES, see the Amazon * SES Developer Guide.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::SendBounceOutcome SendBounce(const Model::SendBounceRequest& request) const; /** * A Callable wrapper for SendBounce that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SendBounceOutcomeCallable SendBounceCallable(const SendBounceRequestT& request) const { return SubmitCallable(&SESClient::SendBounce, request); } /** * An Async wrapper for SendBounce that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SendBounceAsync(const SendBounceRequestT& request, const SendBounceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::SendBounce, request, handler, context); } /** *

Composes an email message to multiple destinations. The message body is * created using an email template.

In order to send email using the * SendBulkTemplatedEmail operation, your call to the API must meet * the following requirements:

  • The call must refer to an existing * email template. You can create email templates using the CreateTemplate * operation.

  • The message must be sent from a verified email * address or domain.

  • If your account is still in the Amazon SES * sandbox, you may only send to verified addresses or domains, or to email * addresses associated with the Amazon SES Mailbox Simulator. For more * information, see Verifying * Email Addresses and Domains in the Amazon SES Developer Guide.

    *

  • The maximum message size is 10 MB.

  • Each * Destination parameter must include at least one recipient email * address. The recipient address can be a To: address, a CC: address, or a BCC: * address. If a recipient email address is invalid (that is, it is not in the * format UserName@[SubDomain.]Domain.TopLevelDomain), the entire message * will be rejected, even if the message contains other recipients that are * valid.

  • The message may not include more than 50 recipients, * across the To:, CC: and BCC: fields. 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 the SendBulkTemplatedEmail operation several times to * send the message to each group.

  • The number of destinations you * can contact in a single call to the API may be limited by your account's maximum * sending rate.

See Also:

AWS * API Reference

*/ virtual Model::SendBulkTemplatedEmailOutcome SendBulkTemplatedEmail(const Model::SendBulkTemplatedEmailRequest& request) const; /** * A Callable wrapper for SendBulkTemplatedEmail that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SendBulkTemplatedEmailOutcomeCallable SendBulkTemplatedEmailCallable(const SendBulkTemplatedEmailRequestT& request) const { return SubmitCallable(&SESClient::SendBulkTemplatedEmail, request); } /** * An Async wrapper for SendBulkTemplatedEmail that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SendBulkTemplatedEmailAsync(const SendBulkTemplatedEmailRequestT& request, const SendBulkTemplatedEmailResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::SendBulkTemplatedEmail, request, handler, context); } /** *

Adds an email address to the list of identities for your Amazon SES account * in the current AWS Region and attempts to verify it. As a result of executing * this operation, a customized verification email is sent to the specified * address.

To use this operation, you must first create a custom * verification email template. For more information about creating and using * custom verification email templates, see Using * Custom Verification Email Templates in the Amazon SES Developer * Guide.

You can execute this operation no more than once per * second.

See Also:

AWS * API Reference

*/ virtual Model::SendCustomVerificationEmailOutcome SendCustomVerificationEmail(const Model::SendCustomVerificationEmailRequest& request) const; /** * A Callable wrapper for SendCustomVerificationEmail that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SendCustomVerificationEmailOutcomeCallable SendCustomVerificationEmailCallable(const SendCustomVerificationEmailRequestT& request) const { return SubmitCallable(&SESClient::SendCustomVerificationEmail, request); } /** * An Async wrapper for SendCustomVerificationEmail that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SendCustomVerificationEmailAsync(const SendCustomVerificationEmailRequestT& request, const SendCustomVerificationEmailResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::SendCustomVerificationEmail, request, handler, context); } /** *

Composes an email message and immediately queues it for sending. In order to * send email using the SendEmail operation, your message must meet * the following requirements:

  • The message must be sent from a * verified email address or domain. If you attempt to send email using a * non-verified address or domain, the operation will result in an "Email address * not verified" error.

  • If your account is still in the Amazon * SES sandbox, you may only send to verified addresses or domains, or to email * addresses associated with the Amazon SES Mailbox Simulator. For more * information, see Verifying * Email Addresses and Domains in the Amazon SES Developer Guide.

    *

  • The maximum message size is 10 MB.

  • The message * must include at least one recipient email address. The recipient address can be * a To: address, a CC: address, or a BCC: address. If a recipient email address is * invalid (that is, it is not in the format * UserName@[SubDomain.]Domain.TopLevelDomain), the entire message will be * rejected, even if the message contains other recipients that are valid.

    *

  • The message may not include more than 50 recipients, across the * To:, CC: and BCC: fields. 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 the SendEmail operation several times to send the message * to each group.

For every message that you send, * the total number of recipients (including each recipient in the To:, CC: and * BCC: fields) is counted against the maximum number of emails you can send in a * 24-hour period (your sending quota). For more information about sending * quotas in Amazon SES, see Managing * Your Amazon SES Sending Limits in the Amazon SES Developer Guide. *

See Also:

AWS API * Reference

*/ virtual Model::SendEmailOutcome SendEmail(const Model::SendEmailRequest& request) const; /** * A Callable wrapper for SendEmail that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SendEmailOutcomeCallable SendEmailCallable(const SendEmailRequestT& request) const { return SubmitCallable(&SESClient::SendEmail, request); } /** * An Async wrapper for SendEmail that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SendEmailAsync(const SendEmailRequestT& request, const SendEmailResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::SendEmail, request, handler, context); } /** *

Composes an email message and immediately queues it for sending.

This * operation is more flexible than the SendEmail API operation. When * you use the SendRawEmail operation, you can specify the headers of * the message as well as its content. This flexibility is useful, for example, * when you want to send a multipart MIME email (such a message that contains both * a text and an HTML version). You can also use this operation to send messages * that include attachments.

The SendRawEmail operation has the * following requirements:

  • You can only send email from verified * email addresses or domains. If you try to send email from an address that * isn't verified, the operation results in an "Email address not verified" * error.

  • If your account is still in the Amazon * SES sandbox, you can only send email to other verified addresses in your * account, or to addresses that are associated with the Amazon * SES mailbox simulator.

  • The maximum message size, including * attachments, is 10 MB.

  • Each message has to include at least * one recipient address. A recipient address includes any address on the To:, CC:, * or BCC: lines.

  • If you send a single message to more than one * recipient address, and one of the recipient addresses isn't in a valid format * (that is, it's not in the format * UserName@[SubDomain.]Domain.TopLevelDomain), Amazon SES rejects the * entire message, even if the other addresses are valid.

  • Each * message can include up to 50 recipient addresses across the To:, CC:, or BCC: * lines. If you need to send a single message to more than 50 recipients, you have * to split the list of recipient addresses into groups of less than 50 recipients, * and send separate messages to each group.

  • Amazon SES allows * you to specify 8-bit Content-Transfer-Encoding for MIME message parts. However, * if Amazon SES has to modify the contents of your message (for example, if you * use open and click tracking), 8-bit content isn't preserved. For this reason, we * highly recommend that you encode all content that isn't 7-bit ASCII. For more * information, see MIME * Encoding in the Amazon SES Developer Guide.

*

Additionally, keep the following considerations in mind when using the * SendRawEmail operation:

  • Although you can customize * the message headers when using the SendRawEmail operation, Amazon * SES will automatically apply its own Message-ID and * Date headers; if you passed these headers when creating the * message, they will be overwritten by the values that Amazon SES provides.

    *

  • 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

    Don't include * these X-headers in the DKIM signature. Amazon SES removes these before it sends * the email.

    If you only specify the * SourceIdentityArn parameter, Amazon SES sets the From and * Return-Path addresses to the same identity that you specified.

    For more * information about sending authorization, see the Using * Sending Authorization with Amazon SES in the Amazon SES Developer * Guide.

  • For every message that you send, the total number * of recipients (including each recipient in the To:, CC: and BCC: fields) is * counted against the maximum number of emails you can send in a 24-hour period * (your sending quota). For more information about sending quotas in Amazon * SES, see Managing * Your Amazon SES Sending Limits in the Amazon SES Developer Guide. *

See Also:

AWS * API Reference

*/ virtual Model::SendRawEmailOutcome SendRawEmail(const Model::SendRawEmailRequest& request) const; /** * A Callable wrapper for SendRawEmail that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SendRawEmailOutcomeCallable SendRawEmailCallable(const SendRawEmailRequestT& request) const { return SubmitCallable(&SESClient::SendRawEmail, request); } /** * An Async wrapper for SendRawEmail that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SendRawEmailAsync(const SendRawEmailRequestT& request, const SendRawEmailResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::SendRawEmail, request, handler, context); } /** *

Composes an email message using an email template and immediately queues it * for sending.

In order to send email using the * SendTemplatedEmail operation, your call to the API must meet the * following requirements:

  • The call must refer to an existing * email template. You can create email templates using the CreateTemplate * operation.

  • The message must be sent from a verified email * address or domain.

  • If your account is still in the Amazon SES * sandbox, you may only send to verified addresses or domains, or to email * addresses associated with the Amazon SES Mailbox Simulator. For more * information, see Verifying * Email Addresses and Domains in the Amazon SES Developer Guide.

    *

  • The maximum message size is 10 MB.

  • Calls to the * SendTemplatedEmail operation may only include one * Destination parameter. A destination is a set of recipients who * will receive the same version of the email. The Destination * parameter can include up to 50 recipients, across the To:, CC: and BCC: * fields.

  • The Destination parameter must include at * least one recipient email address. The recipient address can be a To: address, a * CC: address, or a BCC: address. If a recipient email address is invalid (that * is, it is not in the format UserName@[SubDomain.]Domain.TopLevelDomain), * the entire message will be rejected, even if the message contains other * recipients that are valid.

If your call to the * SendTemplatedEmail operation includes all of the required * parameters, Amazon SES accepts it and returns a Message ID. However, if Amazon * SES can't render the email because the template contains errors, it doesn't send * the email. Additionally, because it already accepted the message, Amazon SES * doesn't return a message stating that it was unable to send the email.

*

For these reasons, we highly recommend that you set up Amazon SES to send you * notifications when Rendering Failure events occur. For more information, see Sending * Personalized Email Using the Amazon SES API in the Amazon Simple Email * Service Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::SendTemplatedEmailOutcome SendTemplatedEmail(const Model::SendTemplatedEmailRequest& request) const; /** * A Callable wrapper for SendTemplatedEmail that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SendTemplatedEmailOutcomeCallable SendTemplatedEmailCallable(const SendTemplatedEmailRequestT& request) const { return SubmitCallable(&SESClient::SendTemplatedEmail, request); } /** * An Async wrapper for SendTemplatedEmail that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SendTemplatedEmailAsync(const SendTemplatedEmailRequestT& request, const SendTemplatedEmailResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::SendTemplatedEmail, request, handler, context); } /** *

Sets the specified receipt rule set as the active receipt rule set.

*

To disable your email-receiving through Amazon SES completely, you can * call this API with RuleSetName set to null.

For information about * managing receipt rule sets, see the Amazon * SES Developer Guide.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::SetActiveReceiptRuleSetOutcome SetActiveReceiptRuleSet(const Model::SetActiveReceiptRuleSetRequest& request) const; /** * A Callable wrapper for SetActiveReceiptRuleSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SetActiveReceiptRuleSetOutcomeCallable SetActiveReceiptRuleSetCallable(const SetActiveReceiptRuleSetRequestT& request) const { return SubmitCallable(&SESClient::SetActiveReceiptRuleSet, request); } /** * An Async wrapper for SetActiveReceiptRuleSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SetActiveReceiptRuleSetAsync(const SetActiveReceiptRuleSetRequestT& request, const SetActiveReceiptRuleSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::SetActiveReceiptRuleSet, request, handler, context); } /** *

Enables or disables Easy DKIM signing of email sent from an identity. If Easy * DKIM signing is enabled for a domain, then Amazon SES uses DKIM to sign all * email that it sends from addresses on that domain. If Easy DKIM signing is * enabled for an email address, then Amazon SES uses DKIM to sign all email it * sends from that address.

For email addresses (for example, * user@example.com), you can only enable DKIM signing if the * corresponding domain (in this case, example.com) has been set up to * use Easy DKIM.

You can enable DKIM signing for an identity at any * time after you start the verification process for the identity, even if the * verification process isn't complete.

You can execute this operation no * more than once per second.

For more information about Easy DKIM signing, * go to the Amazon * SES Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::SetIdentityDkimEnabledOutcome SetIdentityDkimEnabled(const Model::SetIdentityDkimEnabledRequest& request) const; /** * A Callable wrapper for SetIdentityDkimEnabled that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SetIdentityDkimEnabledOutcomeCallable SetIdentityDkimEnabledCallable(const SetIdentityDkimEnabledRequestT& request) const { return SubmitCallable(&SESClient::SetIdentityDkimEnabled, request); } /** * An Async wrapper for SetIdentityDkimEnabled that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SetIdentityDkimEnabledAsync(const SetIdentityDkimEnabledRequestT& request, const SetIdentityDkimEnabledResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::SetIdentityDkimEnabled, request, handler, context); } /** *

Given an identity (an email address or a 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.

*

Feedback forwarding does not apply to delivery notifications. Delivery * notifications are only available through Amazon SNS.

You can * execute this operation no more than once per second.

For more information * about using notifications with Amazon SES, see the Amazon * SES Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::SetIdentityFeedbackForwardingEnabledOutcome SetIdentityFeedbackForwardingEnabled(const Model::SetIdentityFeedbackForwardingEnabledRequest& request) const; /** * A Callable wrapper for SetIdentityFeedbackForwardingEnabled that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SetIdentityFeedbackForwardingEnabledOutcomeCallable SetIdentityFeedbackForwardingEnabledCallable(const SetIdentityFeedbackForwardingEnabledRequestT& request) const { return SubmitCallable(&SESClient::SetIdentityFeedbackForwardingEnabled, request); } /** * An Async wrapper for SetIdentityFeedbackForwardingEnabled that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SetIdentityFeedbackForwardingEnabledAsync(const SetIdentityFeedbackForwardingEnabledRequestT& request, const SetIdentityFeedbackForwardingEnabledResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::SetIdentityFeedbackForwardingEnabled, request, handler, context); } /** *

Given an identity (an email address or a domain), sets whether Amazon SES * includes the original email headers in the Amazon Simple Notification Service * (Amazon SNS) notifications of a specified type.

You can execute this * operation no more than once per second.

For more information about using * notifications with Amazon SES, see the Amazon * SES Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::SetIdentityHeadersInNotificationsEnabledOutcome SetIdentityHeadersInNotificationsEnabled(const Model::SetIdentityHeadersInNotificationsEnabledRequest& request) const; /** * A Callable wrapper for SetIdentityHeadersInNotificationsEnabled that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SetIdentityHeadersInNotificationsEnabledOutcomeCallable SetIdentityHeadersInNotificationsEnabledCallable(const SetIdentityHeadersInNotificationsEnabledRequestT& request) const { return SubmitCallable(&SESClient::SetIdentityHeadersInNotificationsEnabled, request); } /** * An Async wrapper for SetIdentityHeadersInNotificationsEnabled that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SetIdentityHeadersInNotificationsEnabledAsync(const SetIdentityHeadersInNotificationsEnabledRequestT& request, const SetIdentityHeadersInNotificationsEnabledResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::SetIdentityHeadersInNotificationsEnabled, request, handler, context); } /** *

Enables or disables the custom MAIL FROM domain setup for a verified identity * (an email address or a domain).

To send emails using the * specified MAIL FROM domain, you must add an MX record to your MAIL FROM domain's * DNS settings. If you want your emails to pass Sender Policy Framework (SPF) * checks, you must also add or update an SPF record. For more information, see the * Amazon * SES Developer Guide.

You can execute this operation no * more than once per second.

See Also:

AWS * API Reference

*/ virtual Model::SetIdentityMailFromDomainOutcome SetIdentityMailFromDomain(const Model::SetIdentityMailFromDomainRequest& request) const; /** * A Callable wrapper for SetIdentityMailFromDomain that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SetIdentityMailFromDomainOutcomeCallable SetIdentityMailFromDomainCallable(const SetIdentityMailFromDomainRequestT& request) const { return SubmitCallable(&SESClient::SetIdentityMailFromDomain, request); } /** * An Async wrapper for SetIdentityMailFromDomain that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SetIdentityMailFromDomainAsync(const SetIdentityMailFromDomainRequestT& request, const SetIdentityMailFromDomainResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::SetIdentityMailFromDomain, request, handler, context); } /** *

Sets an Amazon Simple Notification Service (Amazon SNS) topic to use when * delivering notifications. When you use this operation, you specify a verified * identity, such as an email address or domain. When you send an email that uses * the chosen identity in the Source field, Amazon SES sends notifications to the * topic you specified. You can send bounce, complaint, or delivery notifications * (or any combination of the three) to the Amazon SNS topic that you specify.

*

You can execute this operation no more than once per second.

For more * information about feedback notification, see the Amazon * SES Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::SetIdentityNotificationTopicOutcome SetIdentityNotificationTopic(const Model::SetIdentityNotificationTopicRequest& request) const; /** * A Callable wrapper for SetIdentityNotificationTopic that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SetIdentityNotificationTopicOutcomeCallable SetIdentityNotificationTopicCallable(const SetIdentityNotificationTopicRequestT& request) const { return SubmitCallable(&SESClient::SetIdentityNotificationTopic, request); } /** * An Async wrapper for SetIdentityNotificationTopic that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SetIdentityNotificationTopicAsync(const SetIdentityNotificationTopicRequestT& request, const SetIdentityNotificationTopicResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::SetIdentityNotificationTopic, request, handler, context); } /** *

Sets the position of the specified receipt rule in the receipt rule set.

*

For information about managing receipt rules, see the Amazon * SES Developer Guide.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::SetReceiptRulePositionOutcome SetReceiptRulePosition(const Model::SetReceiptRulePositionRequest& request) const; /** * A Callable wrapper for SetReceiptRulePosition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SetReceiptRulePositionOutcomeCallable SetReceiptRulePositionCallable(const SetReceiptRulePositionRequestT& request) const { return SubmitCallable(&SESClient::SetReceiptRulePosition, request); } /** * An Async wrapper for SetReceiptRulePosition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SetReceiptRulePositionAsync(const SetReceiptRulePositionRequestT& request, const SetReceiptRulePositionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::SetReceiptRulePosition, request, handler, context); } /** *

Creates a preview of the MIME content of an email when provided with a * template and a set of replacement data.

You can execute this operation no * more than once per second.

See Also:

AWS * API Reference

*/ virtual Model::TestRenderTemplateOutcome TestRenderTemplate(const Model::TestRenderTemplateRequest& request) const; /** * A Callable wrapper for TestRenderTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TestRenderTemplateOutcomeCallable TestRenderTemplateCallable(const TestRenderTemplateRequestT& request) const { return SubmitCallable(&SESClient::TestRenderTemplate, request); } /** * An Async wrapper for TestRenderTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TestRenderTemplateAsync(const TestRenderTemplateRequestT& request, const TestRenderTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::TestRenderTemplate, request, handler, context); } /** *

Enables or disables email sending across your entire Amazon SES account in * the current AWS Region. You can use this operation in conjunction with Amazon * CloudWatch alarms to temporarily pause email sending across your Amazon SES * account in a given AWS Region when reputation metrics (such as your bounce or * complaint rates) reach certain thresholds.

You can execute this operation * no more than once per second.

See Also:

AWS * API Reference

*/ virtual Model::UpdateAccountSendingEnabledOutcome UpdateAccountSendingEnabled(const Model::UpdateAccountSendingEnabledRequest& request) const; /** * A Callable wrapper for UpdateAccountSendingEnabled that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAccountSendingEnabledOutcomeCallable UpdateAccountSendingEnabledCallable(const UpdateAccountSendingEnabledRequestT& request) const { return SubmitCallable(&SESClient::UpdateAccountSendingEnabled, request); } /** * An Async wrapper for UpdateAccountSendingEnabled that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAccountSendingEnabledAsync(const UpdateAccountSendingEnabledRequestT& request, const UpdateAccountSendingEnabledResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::UpdateAccountSendingEnabled, request, handler, context); } /** *

Updates the event destination of a configuration set. Event destinations are * associated with configuration sets, which enable you to publish email sending * events to Amazon CloudWatch, Amazon Kinesis Firehose, or Amazon Simple * Notification Service (Amazon SNS). For information about using configuration * sets, see Monitoring * Your Amazon SES Sending Activity in the Amazon SES Developer Guide. *

When you create or update an event destination, you must provide * one, and only one, destination. The destination can be Amazon CloudWatch, Amazon * Kinesis Firehose, or Amazon Simple Notification Service (Amazon SNS).

*

You can execute this operation no more than once per * second.

See Also:

AWS * API Reference

*/ virtual Model::UpdateConfigurationSetEventDestinationOutcome UpdateConfigurationSetEventDestination(const Model::UpdateConfigurationSetEventDestinationRequest& request) const; /** * A Callable wrapper for UpdateConfigurationSetEventDestination that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateConfigurationSetEventDestinationOutcomeCallable UpdateConfigurationSetEventDestinationCallable(const UpdateConfigurationSetEventDestinationRequestT& request) const { return SubmitCallable(&SESClient::UpdateConfigurationSetEventDestination, request); } /** * An Async wrapper for UpdateConfigurationSetEventDestination that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateConfigurationSetEventDestinationAsync(const UpdateConfigurationSetEventDestinationRequestT& request, const UpdateConfigurationSetEventDestinationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::UpdateConfigurationSetEventDestination, request, handler, context); } /** *

Enables or disables the publishing of reputation metrics for emails sent * using a specific configuration set in a given AWS Region. Reputation metrics * include bounce and complaint rates. These metrics are published to Amazon * CloudWatch. By using CloudWatch, you can create alarms when bounce or complaint * rates exceed certain thresholds.

You can execute this operation no more * than once per second.

See Also:

AWS * API Reference

*/ virtual Model::UpdateConfigurationSetReputationMetricsEnabledOutcome UpdateConfigurationSetReputationMetricsEnabled(const Model::UpdateConfigurationSetReputationMetricsEnabledRequest& request) const; /** * A Callable wrapper for UpdateConfigurationSetReputationMetricsEnabled that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateConfigurationSetReputationMetricsEnabledOutcomeCallable UpdateConfigurationSetReputationMetricsEnabledCallable(const UpdateConfigurationSetReputationMetricsEnabledRequestT& request) const { return SubmitCallable(&SESClient::UpdateConfigurationSetReputationMetricsEnabled, request); } /** * An Async wrapper for UpdateConfigurationSetReputationMetricsEnabled that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateConfigurationSetReputationMetricsEnabledAsync(const UpdateConfigurationSetReputationMetricsEnabledRequestT& request, const UpdateConfigurationSetReputationMetricsEnabledResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::UpdateConfigurationSetReputationMetricsEnabled, request, handler, context); } /** *

Enables or disables email sending for messages sent using a specific * configuration set in a given AWS Region. You can use this operation in * conjunction with Amazon CloudWatch alarms to temporarily pause email sending for * a configuration set when the reputation metrics for that configuration set (such * as your bounce on complaint rate) exceed certain thresholds.

You can * execute this operation no more than once per second.

See Also:

* AWS * API Reference

*/ virtual Model::UpdateConfigurationSetSendingEnabledOutcome UpdateConfigurationSetSendingEnabled(const Model::UpdateConfigurationSetSendingEnabledRequest& request) const; /** * A Callable wrapper for UpdateConfigurationSetSendingEnabled that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateConfigurationSetSendingEnabledOutcomeCallable UpdateConfigurationSetSendingEnabledCallable(const UpdateConfigurationSetSendingEnabledRequestT& request) const { return SubmitCallable(&SESClient::UpdateConfigurationSetSendingEnabled, request); } /** * An Async wrapper for UpdateConfigurationSetSendingEnabled that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateConfigurationSetSendingEnabledAsync(const UpdateConfigurationSetSendingEnabledRequestT& request, const UpdateConfigurationSetSendingEnabledResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::UpdateConfigurationSetSendingEnabled, request, handler, context); } /** *

Modifies an association between a configuration set and a custom domain for * open and click event tracking.

By default, images and links used for * tracking open and click events are hosted on domains operated by Amazon SES. You * can configure a subdomain of your own to handle these events. For information * about using custom domains, see the Amazon * SES Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::UpdateConfigurationSetTrackingOptionsOutcome UpdateConfigurationSetTrackingOptions(const Model::UpdateConfigurationSetTrackingOptionsRequest& request) const; /** * A Callable wrapper for UpdateConfigurationSetTrackingOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateConfigurationSetTrackingOptionsOutcomeCallable UpdateConfigurationSetTrackingOptionsCallable(const UpdateConfigurationSetTrackingOptionsRequestT& request) const { return SubmitCallable(&SESClient::UpdateConfigurationSetTrackingOptions, request); } /** * An Async wrapper for UpdateConfigurationSetTrackingOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateConfigurationSetTrackingOptionsAsync(const UpdateConfigurationSetTrackingOptionsRequestT& request, const UpdateConfigurationSetTrackingOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::UpdateConfigurationSetTrackingOptions, request, handler, context); } /** *

Updates an existing custom verification email template.

For more * information about custom verification email templates, see Using * Custom Verification Email Templates in the Amazon SES Developer * Guide.

You can execute this operation no more than once per * second.

See Also:

AWS * API Reference

*/ virtual Model::UpdateCustomVerificationEmailTemplateOutcome UpdateCustomVerificationEmailTemplate(const Model::UpdateCustomVerificationEmailTemplateRequest& request) const; /** * A Callable wrapper for UpdateCustomVerificationEmailTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateCustomVerificationEmailTemplateOutcomeCallable UpdateCustomVerificationEmailTemplateCallable(const UpdateCustomVerificationEmailTemplateRequestT& request) const { return SubmitCallable(&SESClient::UpdateCustomVerificationEmailTemplate, request); } /** * An Async wrapper for UpdateCustomVerificationEmailTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateCustomVerificationEmailTemplateAsync(const UpdateCustomVerificationEmailTemplateRequestT& request, const UpdateCustomVerificationEmailTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::UpdateCustomVerificationEmailTemplate, request, handler, context); } /** *

Updates a receipt rule.

For information about managing receipt rules, * see the Amazon * SES Developer Guide.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::UpdateReceiptRuleOutcome UpdateReceiptRule(const Model::UpdateReceiptRuleRequest& request) const; /** * A Callable wrapper for UpdateReceiptRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateReceiptRuleOutcomeCallable UpdateReceiptRuleCallable(const UpdateReceiptRuleRequestT& request) const { return SubmitCallable(&SESClient::UpdateReceiptRule, request); } /** * An Async wrapper for UpdateReceiptRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateReceiptRuleAsync(const UpdateReceiptRuleRequestT& request, const UpdateReceiptRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::UpdateReceiptRule, request, handler, context); } /** *

Updates an email template. Email templates enable you to send personalized * email to one or more destinations in a single API operation. For more * information, see the Amazon * SES Developer Guide.

You can execute this operation no more than once * per second.

See Also:

AWS * API Reference

*/ virtual Model::UpdateTemplateOutcome UpdateTemplate(const Model::UpdateTemplateRequest& request) const; /** * A Callable wrapper for UpdateTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateTemplateOutcomeCallable UpdateTemplateCallable(const UpdateTemplateRequestT& request) const { return SubmitCallable(&SESClient::UpdateTemplate, request); } /** * An Async wrapper for UpdateTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateTemplateAsync(const UpdateTemplateRequestT& request, const UpdateTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::UpdateTemplate, request, handler, context); } /** *

Returns a set of DKIM tokens for a domain identity.

When * you execute the VerifyDomainDkim operation, the domain that you * specify is added to the list of identities that are associated with your * account. This is true even if you haven't already associated the domain with * your account by using the VerifyDomainIdentity operation. However, * you can't send email from the domain until you either successfully verify * it or you successfully set * up DKIM for it.

You use the tokens that are generated by * this operation to create CNAME records. When Amazon SES detects that you've * added these records to the DNS configuration for a domain, you can start sending * email from that domain. You can start sending email even if you haven't added * the TXT record provided by the VerifyDomainIdentity operation to the DNS * configuration for your domain. All email that you send from the domain is * authenticated using DKIM.

To create the CNAME records for DKIM * authentication, use the following values:

  • Name: * token._domainkey.example.com

  • Type: * CNAME

  • Value: token.dkim.amazonses.com

    • *

In the preceding example, replace token with one of the tokens * that are generated when you execute this operation. Replace example.com * with your domain. Repeat this process for each token that's generated by this * operation.

You can execute this operation no more than once per * second.

See Also:

AWS * API Reference

*/ virtual Model::VerifyDomainDkimOutcome VerifyDomainDkim(const Model::VerifyDomainDkimRequest& request) const; /** * A Callable wrapper for VerifyDomainDkim that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::VerifyDomainDkimOutcomeCallable VerifyDomainDkimCallable(const VerifyDomainDkimRequestT& request) const { return SubmitCallable(&SESClient::VerifyDomainDkim, request); } /** * An Async wrapper for VerifyDomainDkim that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void VerifyDomainDkimAsync(const VerifyDomainDkimRequestT& request, const VerifyDomainDkimResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::VerifyDomainDkim, request, handler, context); } /** *

Adds a domain to the list of identities for your Amazon SES account in the * current AWS Region and attempts to verify it. For more information about * verifying domains, see Verifying * Email Addresses and Domains in the Amazon SES Developer Guide.

*

You can execute this operation no more than once per second.

See * Also:

AWS * API Reference

*/ virtual Model::VerifyDomainIdentityOutcome VerifyDomainIdentity(const Model::VerifyDomainIdentityRequest& request) const; /** * A Callable wrapper for VerifyDomainIdentity that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::VerifyDomainIdentityOutcomeCallable VerifyDomainIdentityCallable(const VerifyDomainIdentityRequestT& request) const { return SubmitCallable(&SESClient::VerifyDomainIdentity, request); } /** * An Async wrapper for VerifyDomainIdentity that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void VerifyDomainIdentityAsync(const VerifyDomainIdentityRequestT& request, const VerifyDomainIdentityResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::VerifyDomainIdentity, request, handler, context); } /** *

Deprecated. Use the VerifyEmailIdentity operation to verify a * new email address.

See Also:

AWS * API Reference

*/ virtual Model::VerifyEmailAddressOutcome VerifyEmailAddress(const Model::VerifyEmailAddressRequest& request) const; /** * A Callable wrapper for VerifyEmailAddress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::VerifyEmailAddressOutcomeCallable VerifyEmailAddressCallable(const VerifyEmailAddressRequestT& request) const { return SubmitCallable(&SESClient::VerifyEmailAddress, request); } /** * An Async wrapper for VerifyEmailAddress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void VerifyEmailAddressAsync(const VerifyEmailAddressRequestT& request, const VerifyEmailAddressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::VerifyEmailAddress, request, handler, context); } /** *

Adds an email address to the list of identities for your Amazon SES account * in the current AWS region and attempts to verify it. As a result of executing * this operation, a verification email is sent to the specified address.

*

You can execute this operation no more than once per second.

See * Also:

AWS * API Reference

*/ virtual Model::VerifyEmailIdentityOutcome VerifyEmailIdentity(const Model::VerifyEmailIdentityRequest& request) const; /** * A Callable wrapper for VerifyEmailIdentity that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::VerifyEmailIdentityOutcomeCallable VerifyEmailIdentityCallable(const VerifyEmailIdentityRequestT& request) const { return SubmitCallable(&SESClient::VerifyEmailIdentity, request); } /** * An Async wrapper for VerifyEmailIdentity that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void VerifyEmailIdentityAsync(const VerifyEmailIdentityRequestT& request, const VerifyEmailIdentityResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SESClient::VerifyEmailIdentity, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const SESClientConfiguration& clientConfiguration); SESClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace SES } // namespace Aws