@aws-sdk/client-ses 3.32.0 → 3.36.0

package/dist/types/commands/GetCustomVerificationEmailTemplateCommand.d.ts

@@ -1,39 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { GetCustomVerificationEmailTemplateRequest, GetCustomVerificationEmailTemplateResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/GetIdentityDkimAttributesCommand.d.ts

@@ -1,57 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { GetIdentityDkimAttributesRequest, GetIdentityDkimAttributesResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/GetIdentityMailFromDomainAttributesCommand.d.ts

@@ -1,38 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { GetIdentityMailFromDomainAttributesRequest, GetIdentityMailFromDomainAttributesResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/GetIdentityNotificationAttributesCommand.d.ts

@@ -1,40 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { GetIdentityNotificationAttributesRequest, GetIdentityNotificationAttributesResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/GetIdentityPoliciesCommand.d.ts

@@ -1,46 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { GetIdentityPoliciesRequest, GetIdentityPoliciesResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/GetIdentityVerificationAttributesCommand.d.ts

@@ -1,50 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { GetIdentityVerificationAttributesRequest, GetIdentityVerificationAttributesResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/GetSendQuotaCommand.d.ts

@@ -1,36 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { GetSendQuotaResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/GetSendStatisticsCommand.d.ts

@@ -1,38 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { GetSendStatisticsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/GetTemplateCommand.d.ts

@@ -1,37 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { GetTemplateRequest, GetTemplateResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/ListConfigurationSetsCommand.d.ts

@@ -1,44 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { ListConfigurationSetsRequest, ListConfigurationSetsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/ListCustomVerificationEmailTemplatesCommand.d.ts

@@ -1,39 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { ListCustomVerificationEmailTemplatesRequest, ListCustomVerificationEmailTemplatesResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/ListIdentitiesCommand.d.ts

@@ -1,37 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { ListIdentitiesRequest, ListIdentitiesResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/ListIdentityPoliciesCommand.d.ts

@@ -1,46 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { ListIdentityPoliciesRequest, ListIdentityPoliciesResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/ListReceiptFiltersCommand.d.ts

@@ -1,39 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { ListReceiptFiltersRequest, ListReceiptFiltersResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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;
-}