@aws-sdk/client-ses 3.32.0 → 3.36.0

package/dist-types/ts3.4/commands/GetCustomVerificationEmailTemplateCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetCustomVerificationEmailTemplateRequest, GetCustomVerificationEmailTemplateResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESClientResolvedConfig } from "../SESClient";
+export interface GetCustomVerificationEmailTemplateCommandInput extends GetCustomVerificationEmailTemplateRequest {
+}
+export interface GetCustomVerificationEmailTemplateCommandOutput extends GetCustomVerificationEmailTemplateResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns the custom email verification template for the template name you
+ *             specify.</p>
+ *         <p>For more information about custom verification email templates, see <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/custom-verification-emails.html">Using Custom Verification Email Templates</a> in the <i>Amazon SES Developer
+ *                 Guide</i>.</p>
+ *         <p>You can execute this operation no more than once per second.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESClient, GetCustomVerificationEmailTemplateCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, GetCustomVerificationEmailTemplateCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new GetCustomVerificationEmailTemplateCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCustomVerificationEmailTemplateCommandInput} for command's `input` shape.
+ * @see {@link GetCustomVerificationEmailTemplateCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetCustomVerificationEmailTemplateCommand extends $Command<GetCustomVerificationEmailTemplateCommandInput, GetCustomVerificationEmailTemplateCommandOutput, SESClientResolvedConfig> {
+    readonly input: GetCustomVerificationEmailTemplateCommandInput;
+    constructor(input: GetCustomVerificationEmailTemplateCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCustomVerificationEmailTemplateCommandInput, GetCustomVerificationEmailTemplateCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetIdentityDkimAttributesCommand.d.ts

@@ -0,0 +1,57 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetIdentityDkimAttributesRequest, GetIdentityDkimAttributesResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESClientResolvedConfig } from "../SESClient";
+export interface GetIdentityDkimAttributesCommandInput extends GetIdentityDkimAttributesRequest {
+}
+export interface GetIdentityDkimAttributesCommandOutput extends GetIdentityDkimAttributesResponse, __MetadataBearer {
+}
+/**
+ * <p>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.</p>
+ *         <p>This operation takes a list of identities as input and returns the following
+ *             information for each:</p>
+ *         <ul>
+ *             <li>
+ *                 <p>Whether Easy DKIM signing is enabled or disabled.</p>
+ *             </li>
+ *             <li>
+ *                 <p>A set of DKIM tokens that represent the identity. If the identity is an email
+ *                     address, the tokens represent the domain of that address.</p>
+ *             </li>
+ *             <li>
+ *                 <p>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.</p>
+ *             </li>
+ *          </ul>
+ *         <p>This operation is throttled at one request per second and can only get DKIM attributes
+ *             for up to 100 identities at a time.</p>
+ *         <p>For more information about creating DNS records using DKIM tokens, go to the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/easy-dkim-dns-records.html">Amazon SES Developer Guide</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESClient, GetIdentityDkimAttributesCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, GetIdentityDkimAttributesCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new GetIdentityDkimAttributesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetIdentityDkimAttributesCommandInput} for command's `input` shape.
+ * @see {@link GetIdentityDkimAttributesCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetIdentityDkimAttributesCommand extends $Command<GetIdentityDkimAttributesCommandInput, GetIdentityDkimAttributesCommandOutput, SESClientResolvedConfig> {
+    readonly input: GetIdentityDkimAttributesCommandInput;
+    constructor(input: GetIdentityDkimAttributesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetIdentityDkimAttributesCommandInput, GetIdentityDkimAttributesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetIdentityMailFromDomainAttributesCommand.d.ts

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetIdentityMailFromDomainAttributesRequest, GetIdentityMailFromDomainAttributesResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESClientResolvedConfig } from "../SESClient";
+export interface GetIdentityMailFromDomainAttributesCommandInput extends GetIdentityMailFromDomainAttributesRequest {
+}
+export interface GetIdentityMailFromDomainAttributesCommandOutput extends GetIdentityMailFromDomainAttributesResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns the custom MAIL FROM attributes for a list of identities (email addresses :
+ *             domains).</p>
+ *         <p>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.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESClient, GetIdentityMailFromDomainAttributesCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, GetIdentityMailFromDomainAttributesCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new GetIdentityMailFromDomainAttributesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetIdentityMailFromDomainAttributesCommandInput} for command's `input` shape.
+ * @see {@link GetIdentityMailFromDomainAttributesCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetIdentityMailFromDomainAttributesCommand extends $Command<GetIdentityMailFromDomainAttributesCommandInput, GetIdentityMailFromDomainAttributesCommandOutput, SESClientResolvedConfig> {
+    readonly input: GetIdentityMailFromDomainAttributesCommandInput;
+    constructor(input: GetIdentityMailFromDomainAttributesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetIdentityMailFromDomainAttributesCommandInput, GetIdentityMailFromDomainAttributesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetIdentityNotificationAttributesCommand.d.ts

@@ -0,0 +1,40 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetIdentityNotificationAttributesRequest, GetIdentityNotificationAttributesResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESClientResolvedConfig } from "../SESClient";
+export interface GetIdentityNotificationAttributesCommandInput extends GetIdentityNotificationAttributesRequest {
+}
+export interface GetIdentityNotificationAttributesCommandOutput extends GetIdentityNotificationAttributesResponse, __MetadataBearer {
+}
+/**
+ * <p>Given a list of verified identities (email addresses and/or domains), returns a
+ *             structure describing identity notification attributes.</p>
+ *         <p>This operation is throttled at one request per second and can only get notification
+ *             attributes for up to 100 identities at a time.</p>
+ *         <p>For more information about using notifications with Amazon SES, see the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/notifications.html">Amazon SES
+ *                 Developer Guide</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESClient, GetIdentityNotificationAttributesCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, GetIdentityNotificationAttributesCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new GetIdentityNotificationAttributesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetIdentityNotificationAttributesCommandInput} for command's `input` shape.
+ * @see {@link GetIdentityNotificationAttributesCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetIdentityNotificationAttributesCommand extends $Command<GetIdentityNotificationAttributesCommandInput, GetIdentityNotificationAttributesCommandOutput, SESClientResolvedConfig> {
+    readonly input: GetIdentityNotificationAttributesCommandInput;
+    constructor(input: GetIdentityNotificationAttributesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetIdentityNotificationAttributesCommandInput, GetIdentityNotificationAttributesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetIdentityPoliciesCommand.d.ts

@@ -0,0 +1,46 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetIdentityPoliciesRequest, GetIdentityPoliciesResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESClientResolvedConfig } from "../SESClient";
+export interface GetIdentityPoliciesCommandInput extends GetIdentityPoliciesRequest {
+}
+export interface GetIdentityPoliciesCommandOutput extends GetIdentityPoliciesResponse, __MetadataBearer {
+}
+/**
+ * <p>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.</p>
+ *         <note>
+ *             <p>This API is for the identity owner only. If you have not verified the identity,
+ *                 this API will return an error.</p>
+ *         </note>
+ *         <p>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 <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/sending-authorization.html">Amazon SES Developer
+ *                 Guide</a>.</p>
+ *         <p>You can execute this operation no more than once per second.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESClient, GetIdentityPoliciesCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, GetIdentityPoliciesCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new GetIdentityPoliciesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetIdentityPoliciesCommandInput} for command's `input` shape.
+ * @see {@link GetIdentityPoliciesCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetIdentityPoliciesCommand extends $Command<GetIdentityPoliciesCommandInput, GetIdentityPoliciesCommandOutput, SESClientResolvedConfig> {
+    readonly input: GetIdentityPoliciesCommandInput;
+    constructor(input: GetIdentityPoliciesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetIdentityPoliciesCommandInput, GetIdentityPoliciesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetIdentityVerificationAttributesCommand.d.ts

@@ -0,0 +1,50 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetIdentityVerificationAttributesRequest, GetIdentityVerificationAttributesResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESClientResolvedConfig } from "../SESClient";
+export interface GetIdentityVerificationAttributesCommandInput extends GetIdentityVerificationAttributesRequest {
+}
+export interface GetIdentityVerificationAttributesCommandOutput extends GetIdentityVerificationAttributesResponse, __MetadataBearer {
+}
+/**
+ * <p>Given a list of identities (email addresses and/or domains), returns the verification
+ *             status and (for domain identities) the verification token for each identity.</p>
+ *         <p>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.</p>
+ *         <p>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.</p>
+ *         <p>This operation is throttled at one request per second and can only get verification
+ *             attributes for up to 100 identities at a time.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESClient, GetIdentityVerificationAttributesCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, GetIdentityVerificationAttributesCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new GetIdentityVerificationAttributesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetIdentityVerificationAttributesCommandInput} for command's `input` shape.
+ * @see {@link GetIdentityVerificationAttributesCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetIdentityVerificationAttributesCommand extends $Command<GetIdentityVerificationAttributesCommandInput, GetIdentityVerificationAttributesCommandOutput, SESClientResolvedConfig> {
+    readonly input: GetIdentityVerificationAttributesCommandInput;
+    constructor(input: GetIdentityVerificationAttributesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetIdentityVerificationAttributesCommandInput, GetIdentityVerificationAttributesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetSendQuotaCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetSendQuotaResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESClientResolvedConfig } from "../SESClient";
+export interface GetSendQuotaCommandInput {
+}
+export interface GetSendQuotaCommandOutput extends GetSendQuotaResponse, __MetadataBearer {
+}
+/**
+ * <p>Provides the sending limits for the Amazon SES account. </p>
+ *         <p>You can execute this operation no more than once per second.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESClient, GetSendQuotaCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, GetSendQuotaCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new GetSendQuotaCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSendQuotaCommandInput} for command's `input` shape.
+ * @see {@link GetSendQuotaCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetSendQuotaCommand extends $Command<GetSendQuotaCommandInput, GetSendQuotaCommandOutput, SESClientResolvedConfig> {
+    readonly input: GetSendQuotaCommandInput;
+    constructor(input: GetSendQuotaCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSendQuotaCommandInput, GetSendQuotaCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetSendStatisticsCommand.d.ts

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetSendStatisticsResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESClientResolvedConfig } from "../SESClient";
+export interface GetSendStatisticsCommandInput {
+}
+export interface GetSendStatisticsCommandOutput extends GetSendStatisticsResponse, __MetadataBearer {
+}
+/**
+ * <p>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.</p>
+ *         <p>You can execute this operation no more than once per second.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESClient, GetSendStatisticsCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, GetSendStatisticsCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new GetSendStatisticsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSendStatisticsCommandInput} for command's `input` shape.
+ * @see {@link GetSendStatisticsCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetSendStatisticsCommand extends $Command<GetSendStatisticsCommandInput, GetSendStatisticsCommandOutput, SESClientResolvedConfig> {
+    readonly input: GetSendStatisticsCommandInput;
+    constructor(input: GetSendStatisticsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSendStatisticsCommandInput, GetSendStatisticsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetTemplateCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetTemplateRequest, GetTemplateResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESClientResolvedConfig } from "../SESClient";
+export interface GetTemplateCommandInput extends GetTemplateRequest {
+}
+export interface GetTemplateCommandOutput extends GetTemplateResponse, __MetadataBearer {
+}
+/**
+ * <p>Displays the template object (which includes the Subject line, HTML part and text
+ *             part) for the template you specify.</p>
+ *         <p>You can execute this operation no more than once per second.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESClient, GetTemplateCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, GetTemplateCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new GetTemplateCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetTemplateCommandInput} for command's `input` shape.
+ * @see {@link GetTemplateCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetTemplateCommand extends $Command<GetTemplateCommandInput, GetTemplateCommandOutput, SESClientResolvedConfig> {
+    readonly input: GetTemplateCommandInput;
+    constructor(input: GetTemplateCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetTemplateCommandInput, GetTemplateCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListConfigurationSetsCommand.d.ts

@@ -0,0 +1,44 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListConfigurationSetsRequest, ListConfigurationSetsResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESClientResolvedConfig } from "../SESClient";
+export interface ListConfigurationSetsCommandInput extends ListConfigurationSetsRequest {
+}
+export interface ListConfigurationSetsCommandOutput extends ListConfigurationSetsResponse, __MetadataBearer {
+}
+/**
+ * <p>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 <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/monitor-sending-activity.html">Monitoring Your Amazon SES Sending Activity</a> in the <i>Amazon SES Developer
+ *                 Guide.</i>
+ *          </p>
+ *         <p>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 <code>ListConfigurationSets</code> operation again, passing the
+ *                 <code>NextToken</code> parameter and the value of the NextToken element to retrieve
+ *             additional results.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESClient, ListConfigurationSetsCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, ListConfigurationSetsCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new ListConfigurationSetsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListConfigurationSetsCommandInput} for command's `input` shape.
+ * @see {@link ListConfigurationSetsCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListConfigurationSetsCommand extends $Command<ListConfigurationSetsCommandInput, ListConfigurationSetsCommandOutput, SESClientResolvedConfig> {
+    readonly input: ListConfigurationSetsCommandInput;
+    constructor(input: ListConfigurationSetsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListConfigurationSetsCommandInput, ListConfigurationSetsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListCustomVerificationEmailTemplatesCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListCustomVerificationEmailTemplatesRequest, ListCustomVerificationEmailTemplatesResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESClientResolvedConfig } from "../SESClient";
+export interface ListCustomVerificationEmailTemplatesCommandInput extends ListCustomVerificationEmailTemplatesRequest {
+}
+export interface ListCustomVerificationEmailTemplatesCommandOutput extends ListCustomVerificationEmailTemplatesResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the existing custom verification email templates for your account in the current
+ *             AWS Region.</p>
+ *         <p>For more information about custom verification email templates, see <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/custom-verification-emails.html">Using Custom Verification Email Templates</a> in the <i>Amazon SES Developer
+ *                 Guide</i>.</p>
+ *         <p>You can execute this operation no more than once per second.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESClient, ListCustomVerificationEmailTemplatesCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, ListCustomVerificationEmailTemplatesCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new ListCustomVerificationEmailTemplatesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListCustomVerificationEmailTemplatesCommandInput} for command's `input` shape.
+ * @see {@link ListCustomVerificationEmailTemplatesCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListCustomVerificationEmailTemplatesCommand extends $Command<ListCustomVerificationEmailTemplatesCommandInput, ListCustomVerificationEmailTemplatesCommandOutput, SESClientResolvedConfig> {
+    readonly input: ListCustomVerificationEmailTemplatesCommandInput;
+    constructor(input: ListCustomVerificationEmailTemplatesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListCustomVerificationEmailTemplatesCommandInput, ListCustomVerificationEmailTemplatesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListIdentitiesCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListIdentitiesRequest, ListIdentitiesResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESClientResolvedConfig } from "../SESClient";
+export interface ListIdentitiesCommandInput extends ListIdentitiesRequest {
+}
+export interface ListIdentitiesCommandOutput extends ListIdentitiesResponse, __MetadataBearer {
+}
+/**
+ * <p>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.</p>
+ *         <p>You can execute this operation no more than once per second.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESClient, ListIdentitiesCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, ListIdentitiesCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new ListIdentitiesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListIdentitiesCommandInput} for command's `input` shape.
+ * @see {@link ListIdentitiesCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListIdentitiesCommand extends $Command<ListIdentitiesCommandInput, ListIdentitiesCommandOutput, SESClientResolvedConfig> {
+    readonly input: ListIdentitiesCommandInput;
+    constructor(input: ListIdentitiesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListIdentitiesCommandInput, ListIdentitiesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListIdentityPoliciesCommand.d.ts

@@ -0,0 +1,46 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListIdentityPoliciesRequest, ListIdentityPoliciesResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESClientResolvedConfig } from "../SESClient";
+export interface ListIdentityPoliciesCommandInput extends ListIdentityPoliciesRequest {
+}
+export interface ListIdentityPoliciesCommandOutput extends ListIdentityPoliciesResponse, __MetadataBearer {
+}
+/**
+ * <p>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 <code>GetIdentityPolicies</code>.</p>
+ *         <note>
+ *             <p>This API is for the identity owner only. If you have not verified the identity,
+ *                 this API will return an error.</p>
+ *         </note>
+ *         <p>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 <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/sending-authorization.html">Amazon SES Developer
+ *                 Guide</a>.</p>
+ *         <p>You can execute this operation no more than once per second.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESClient, ListIdentityPoliciesCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, ListIdentityPoliciesCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new ListIdentityPoliciesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListIdentityPoliciesCommandInput} for command's `input` shape.
+ * @see {@link ListIdentityPoliciesCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListIdentityPoliciesCommand extends $Command<ListIdentityPoliciesCommandInput, ListIdentityPoliciesCommandOutput, SESClientResolvedConfig> {
+    readonly input: ListIdentityPoliciesCommandInput;
+    constructor(input: ListIdentityPoliciesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListIdentityPoliciesCommandInput, ListIdentityPoliciesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListReceiptFiltersCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListReceiptFiltersRequest, ListReceiptFiltersResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESClientResolvedConfig } from "../SESClient";
+export interface ListReceiptFiltersCommandInput extends ListReceiptFiltersRequest {
+}
+export interface ListReceiptFiltersCommandOutput extends ListReceiptFiltersResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the IP address filters associated with your AWS account in the current AWS
+ *             Region.</p>
+ *         <p>For information about managing IP address filters, see the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/receiving-email-managing-ip-filters.html">Amazon SES
+ *                 Developer Guide</a>.</p>
+ *         <p>You can execute this operation no more than once per second.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESClient, ListReceiptFiltersCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, ListReceiptFiltersCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new ListReceiptFiltersCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListReceiptFiltersCommandInput} for command's `input` shape.
+ * @see {@link ListReceiptFiltersCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListReceiptFiltersCommand extends $Command<ListReceiptFiltersCommandInput, ListReceiptFiltersCommandOutput, SESClientResolvedConfig> {
+    readonly input: ListReceiptFiltersCommandInput;
+    constructor(input: ListReceiptFiltersCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListReceiptFiltersCommandInput, ListReceiptFiltersCommandOutput>;
+    private serialize;
+    private deserialize;
+}