@aws-sdk/client-sesv2 3.32.0 → 3.36.0

package/dist-types/commands/CreateEmailTemplateCommand.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 { CreateEmailTemplateRequest, CreateEmailTemplateResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface CreateEmailTemplateCommandInput extends CreateEmailTemplateRequest {
+}
+export interface CreateEmailTemplateCommandOutput extends CreateEmailTemplateResponse, __MetadataBearer {
+}
+/**
+ * <p>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 <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-personalized-email-api.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 { SESv2Client, CreateEmailTemplateCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, CreateEmailTemplateCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new CreateEmailTemplateCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateEmailTemplateCommandInput} for command's `input` shape.
+ * @see {@link CreateEmailTemplateCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateEmailTemplateCommand extends $Command<CreateEmailTemplateCommandInput, CreateEmailTemplateCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: CreateEmailTemplateCommandInput;
+    constructor(input: CreateEmailTemplateCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateEmailTemplateCommandInput, CreateEmailTemplateCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateImportJobCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateImportJobRequest, CreateImportJobResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface CreateImportJobCommandInput extends CreateImportJobRequest {
+}
+export interface CreateImportJobCommandOutput extends CreateImportJobResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates an import job for a data destination.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESv2Client, CreateImportJobCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, CreateImportJobCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new CreateImportJobCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateImportJobCommandInput} for command's `input` shape.
+ * @see {@link CreateImportJobCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateImportJobCommand extends $Command<CreateImportJobCommandInput, CreateImportJobCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: CreateImportJobCommandInput;
+    constructor(input: CreateImportJobCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateImportJobCommandInput, CreateImportJobCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteConfigurationSetCommand.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 { DeleteConfigurationSetRequest, DeleteConfigurationSetResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface DeleteConfigurationSetCommandInput extends DeleteConfigurationSetRequest {
+}
+export interface DeleteConfigurationSetCommandOutput extends DeleteConfigurationSetResponse, __MetadataBearer {
+}
+/**
+ * <p>Delete an existing configuration set.</p>
+ *         <p>
+ *             <i>Configuration sets</i> are groups of rules that you can apply to the
+ *             emails you send. You apply a configuration set to an email by including a reference to
+ *             the configuration set in the headers of the email. When you apply a configuration set to
+ *             an email, all of the rules in that configuration set are applied to the email.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESv2Client, DeleteConfigurationSetCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, DeleteConfigurationSetCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new DeleteConfigurationSetCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteConfigurationSetCommandInput} for command's `input` shape.
+ * @see {@link DeleteConfigurationSetCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteConfigurationSetCommand extends $Command<DeleteConfigurationSetCommandInput, DeleteConfigurationSetCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: DeleteConfigurationSetCommandInput;
+    constructor(input: DeleteConfigurationSetCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteConfigurationSetCommandInput, DeleteConfigurationSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteConfigurationSetEventDestinationCommand.d.ts

@@ -0,0 +1,41 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteConfigurationSetEventDestinationRequest, DeleteConfigurationSetEventDestinationResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface DeleteConfigurationSetEventDestinationCommandInput extends DeleteConfigurationSetEventDestinationRequest {
+}
+export interface DeleteConfigurationSetEventDestinationCommandOutput extends DeleteConfigurationSetEventDestinationResponse, __MetadataBearer {
+}
+/**
+ * <p>Delete an event destination.</p>
+ *         <p>
+ *             <i>Events</i> include message sends, deliveries, opens, clicks, bounces,
+ *             and complaints. <i>Event destinations</i> are places that you can send
+ *             information about these events to. For example, you can send event data to Amazon SNS to
+ *             receive notifications when you receive bounces or complaints, or you can use Amazon Kinesis Data Firehose to
+ *             stream data to Amazon S3 for long-term storage.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESv2Client, DeleteConfigurationSetEventDestinationCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, DeleteConfigurationSetEventDestinationCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new DeleteConfigurationSetEventDestinationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteConfigurationSetEventDestinationCommandInput} for command's `input` shape.
+ * @see {@link DeleteConfigurationSetEventDestinationCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteConfigurationSetEventDestinationCommand extends $Command<DeleteConfigurationSetEventDestinationCommandInput, DeleteConfigurationSetEventDestinationCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: DeleteConfigurationSetEventDestinationCommandInput;
+    constructor(input: DeleteConfigurationSetEventDestinationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteConfigurationSetEventDestinationCommandInput, DeleteConfigurationSetEventDestinationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteContactCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteContactRequest, DeleteContactResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface DeleteContactCommandInput extends DeleteContactRequest {
+}
+export interface DeleteContactCommandOutput extends DeleteContactResponse, __MetadataBearer {
+}
+/**
+ * <p>Removes a contact from a contact list.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESv2Client, DeleteContactCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, DeleteContactCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new DeleteContactCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteContactCommandInput} for command's `input` shape.
+ * @see {@link DeleteContactCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteContactCommand extends $Command<DeleteContactCommandInput, DeleteContactCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: DeleteContactCommandInput;
+    constructor(input: DeleteContactCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteContactCommandInput, DeleteContactCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteContactListCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteContactListRequest, DeleteContactListResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface DeleteContactListCommandInput extends DeleteContactListRequest {
+}
+export interface DeleteContactListCommandOutput extends DeleteContactListResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes a contact list and all of the contacts on that list.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESv2Client, DeleteContactListCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, DeleteContactListCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new DeleteContactListCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteContactListCommandInput} for command's `input` shape.
+ * @see {@link DeleteContactListCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteContactListCommand extends $Command<DeleteContactListCommandInput, DeleteContactListCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: DeleteContactListCommandInput;
+    constructor(input: DeleteContactListCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteContactListCommandInput, DeleteContactListCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteCustomVerificationEmailTemplateCommand.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 { DeleteCustomVerificationEmailTemplateRequest, DeleteCustomVerificationEmailTemplateResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface DeleteCustomVerificationEmailTemplateCommandInput extends DeleteCustomVerificationEmailTemplateRequest {
+}
+export interface DeleteCustomVerificationEmailTemplateCommandOutput extends DeleteCustomVerificationEmailTemplateResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes an existing custom verification email template.</p>
+ *         <p>For more information about custom verification email templates, see <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-verify-address-custom.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 { SESv2Client, DeleteCustomVerificationEmailTemplateCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, DeleteCustomVerificationEmailTemplateCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new DeleteCustomVerificationEmailTemplateCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteCustomVerificationEmailTemplateCommandInput} for command's `input` shape.
+ * @see {@link DeleteCustomVerificationEmailTemplateCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteCustomVerificationEmailTemplateCommand extends $Command<DeleteCustomVerificationEmailTemplateCommandInput, DeleteCustomVerificationEmailTemplateCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: DeleteCustomVerificationEmailTemplateCommandInput;
+    constructor(input: DeleteCustomVerificationEmailTemplateCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCustomVerificationEmailTemplateCommandInput, DeleteCustomVerificationEmailTemplateCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteDedicatedIpPoolCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteDedicatedIpPoolRequest, DeleteDedicatedIpPoolResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface DeleteDedicatedIpPoolCommandInput extends DeleteDedicatedIpPoolRequest {
+}
+export interface DeleteDedicatedIpPoolCommandOutput extends DeleteDedicatedIpPoolResponse, __MetadataBearer {
+}
+/**
+ * <p>Delete a dedicated IP pool.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESv2Client, DeleteDedicatedIpPoolCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, DeleteDedicatedIpPoolCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new DeleteDedicatedIpPoolCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteDedicatedIpPoolCommandInput} for command's `input` shape.
+ * @see {@link DeleteDedicatedIpPoolCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteDedicatedIpPoolCommand extends $Command<DeleteDedicatedIpPoolCommandInput, DeleteDedicatedIpPoolCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: DeleteDedicatedIpPoolCommandInput;
+    constructor(input: DeleteDedicatedIpPoolCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDedicatedIpPoolCommandInput, DeleteDedicatedIpPoolCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteEmailIdentityCommand.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 { DeleteEmailIdentityRequest, DeleteEmailIdentityResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface DeleteEmailIdentityCommandInput extends DeleteEmailIdentityRequest {
+}
+export interface DeleteEmailIdentityCommandOutput extends DeleteEmailIdentityResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes an email identity. An identity can be either an email address or a domain
+ *             name.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESv2Client, DeleteEmailIdentityCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, DeleteEmailIdentityCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new DeleteEmailIdentityCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteEmailIdentityCommandInput} for command's `input` shape.
+ * @see {@link DeleteEmailIdentityCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteEmailIdentityCommand extends $Command<DeleteEmailIdentityCommandInput, DeleteEmailIdentityCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: DeleteEmailIdentityCommandInput;
+    constructor(input: DeleteEmailIdentityCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEmailIdentityCommandInput, DeleteEmailIdentityCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteEmailIdentityPolicyCommand.d.ts

@@ -0,0 +1,47 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteEmailIdentityPolicyRequest, DeleteEmailIdentityPolicyResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface DeleteEmailIdentityPolicyCommandInput extends DeleteEmailIdentityPolicyRequest {
+}
+export interface DeleteEmailIdentityPolicyCommandOutput extends DeleteEmailIdentityPolicyResponse, __MetadataBearer {
+}
+/**
+ * <p>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.</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 { SESv2Client, DeleteEmailIdentityPolicyCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, DeleteEmailIdentityPolicyCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new DeleteEmailIdentityPolicyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteEmailIdentityPolicyCommandInput} for command's `input` shape.
+ * @see {@link DeleteEmailIdentityPolicyCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteEmailIdentityPolicyCommand extends $Command<DeleteEmailIdentityPolicyCommandInput, DeleteEmailIdentityPolicyCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: DeleteEmailIdentityPolicyCommandInput;
+    constructor(input: DeleteEmailIdentityPolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEmailIdentityPolicyCommandInput, DeleteEmailIdentityPolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteEmailTemplateCommand.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 { DeleteEmailTemplateRequest, DeleteEmailTemplateResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface DeleteEmailTemplateCommandInput extends DeleteEmailTemplateRequest {
+}
+export interface DeleteEmailTemplateCommandOutput extends DeleteEmailTemplateResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes an email template.</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 { SESv2Client, DeleteEmailTemplateCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, DeleteEmailTemplateCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new DeleteEmailTemplateCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteEmailTemplateCommandInput} for command's `input` shape.
+ * @see {@link DeleteEmailTemplateCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteEmailTemplateCommand extends $Command<DeleteEmailTemplateCommandInput, DeleteEmailTemplateCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: DeleteEmailTemplateCommandInput;
+    constructor(input: DeleteEmailTemplateCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEmailTemplateCommandInput, DeleteEmailTemplateCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteSuppressedDestinationCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteSuppressedDestinationRequest, DeleteSuppressedDestinationResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface DeleteSuppressedDestinationCommandInput extends DeleteSuppressedDestinationRequest {
+}
+export interface DeleteSuppressedDestinationCommandOutput extends DeleteSuppressedDestinationResponse, __MetadataBearer {
+}
+/**
+ * <p>Removes an email address from the suppression list for your account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESv2Client, DeleteSuppressedDestinationCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, DeleteSuppressedDestinationCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new DeleteSuppressedDestinationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteSuppressedDestinationCommandInput} for command's `input` shape.
+ * @see {@link DeleteSuppressedDestinationCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteSuppressedDestinationCommand extends $Command<DeleteSuppressedDestinationCommandInput, DeleteSuppressedDestinationCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: DeleteSuppressedDestinationCommandInput;
+    constructor(input: DeleteSuppressedDestinationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSuppressedDestinationCommandInput, DeleteSuppressedDestinationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetAccountCommand.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 { GetAccountRequest, GetAccountResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface GetAccountCommandInput extends GetAccountRequest {
+}
+export interface GetAccountCommandOutput extends GetAccountResponse, __MetadataBearer {
+}
+/**
+ * <p>Obtain information about the email-sending status and capabilities of your Amazon SES
+ *             account in the current Amazon Web Services Region.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESv2Client, GetAccountCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, GetAccountCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new GetAccountCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetAccountCommandInput} for command's `input` shape.
+ * @see {@link GetAccountCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetAccountCommand extends $Command<GetAccountCommandInput, GetAccountCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: GetAccountCommandInput;
+    constructor(input: GetAccountCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAccountCommandInput, GetAccountCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetBlacklistReportsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetBlacklistReportsRequest, GetBlacklistReportsResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface GetBlacklistReportsCommandInput extends GetBlacklistReportsRequest {
+}
+export interface GetBlacklistReportsCommandOutput extends GetBlacklistReportsResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieve a list of the blacklists that your dedicated IP addresses appear on.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESv2Client, GetBlacklistReportsCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, GetBlacklistReportsCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new GetBlacklistReportsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBlacklistReportsCommandInput} for command's `input` shape.
+ * @see {@link GetBlacklistReportsCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetBlacklistReportsCommand extends $Command<GetBlacklistReportsCommandInput, GetBlacklistReportsCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: GetBlacklistReportsCommandInput;
+    constructor(input: GetBlacklistReportsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBlacklistReportsCommandInput, GetBlacklistReportsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetConfigurationSetCommand.d.ts

@@ -0,0 +1,42 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetConfigurationSetRequest, GetConfigurationSetResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface GetConfigurationSetCommandInput extends GetConfigurationSetRequest {
+}
+export interface GetConfigurationSetCommandOutput extends GetConfigurationSetResponse, __MetadataBearer {
+}
+/**
+ * <p>Get information about an existing configuration set, including the dedicated IP pool
+ *             that it's associated with, whether or not it's enabled for sending email, and
+ *             more.</p>
+ *         <p>
+ *             <i>Configuration sets</i> are groups of rules that you can apply to the
+ *             emails you send. You apply a configuration set to an email by including a reference to
+ *             the configuration set in the headers of the email. When you apply a configuration set to
+ *             an email, all of the rules in that configuration set are applied to the email.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESv2Client, GetConfigurationSetCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, GetConfigurationSetCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new GetConfigurationSetCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetConfigurationSetCommandInput} for command's `input` shape.
+ * @see {@link GetConfigurationSetCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetConfigurationSetCommand extends $Command<GetConfigurationSetCommandInput, GetConfigurationSetCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: GetConfigurationSetCommandInput;
+    constructor(input: GetConfigurationSetCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetConfigurationSetCommandInput, GetConfigurationSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetConfigurationSetEventDestinationsCommand.d.ts

@@ -0,0 +1,42 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetConfigurationSetEventDestinationsRequest, GetConfigurationSetEventDestinationsResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface GetConfigurationSetEventDestinationsCommandInput extends GetConfigurationSetEventDestinationsRequest {
+}
+export interface GetConfigurationSetEventDestinationsCommandOutput extends GetConfigurationSetEventDestinationsResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieve a list of event destinations that are associated with a configuration
+ *             set.</p>
+ *         <p>
+ *             <i>Events</i> include message sends, deliveries, opens, clicks, bounces,
+ *             and complaints. <i>Event destinations</i> are places that you can send
+ *             information about these events to. For example, you can send event data to Amazon SNS to
+ *             receive notifications when you receive bounces or complaints, or you can use Amazon Kinesis Data Firehose to
+ *             stream data to Amazon S3 for long-term storage.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESv2Client, GetConfigurationSetEventDestinationsCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, GetConfigurationSetEventDestinationsCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new GetConfigurationSetEventDestinationsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetConfigurationSetEventDestinationsCommandInput} for command's `input` shape.
+ * @see {@link GetConfigurationSetEventDestinationsCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetConfigurationSetEventDestinationsCommand extends $Command<GetConfigurationSetEventDestinationsCommandInput, GetConfigurationSetEventDestinationsCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: GetConfigurationSetEventDestinationsCommandInput;
+    constructor(input: GetConfigurationSetEventDestinationsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetConfigurationSetEventDestinationsCommandInput, GetConfigurationSetEventDestinationsCommandOutput>;
+    private serialize;
+    private deserialize;
+}