@aws-sdk/client-sesv2 3.32.0 → 3.36.0

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

package/dist-types/ts3.4/commands/GetContactListCommand.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 { GetContactListRequest, GetContactListResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface GetContactListCommandInput extends GetContactListRequest {
+}
+export interface GetContactListCommandOutput extends GetContactListResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns contact list metadata. It does not return any information about the contacts
+ *             present in the list.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESv2Client, GetContactListCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, GetContactListCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new GetContactListCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetContactListCommandInput} for command's `input` shape.
+ * @see {@link GetContactListCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetContactListCommand extends $Command<GetContactListCommandInput, GetContactListCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: GetContactListCommandInput;
+    constructor(input: GetContactListCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetContactListCommandInput, GetContactListCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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, SESv2ClientResolvedConfig } from "../SESv2Client";
+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/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, GetCustomVerificationEmailTemplateCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, GetCustomVerificationEmailTemplateCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(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 SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetCustomVerificationEmailTemplateCommand extends $Command<GetCustomVerificationEmailTemplateCommandInput, GetCustomVerificationEmailTemplateCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: GetCustomVerificationEmailTemplateCommandInput;
+    constructor(input: GetCustomVerificationEmailTemplateCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCustomVerificationEmailTemplateCommandInput, GetCustomVerificationEmailTemplateCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetDedicatedIpCommand.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 { GetDedicatedIpRequest, GetDedicatedIpResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface GetDedicatedIpCommandInput extends GetDedicatedIpRequest {
+}
+export interface GetDedicatedIpCommandOutput extends GetDedicatedIpResponse, __MetadataBearer {
+}
+/**
+ * <p>Get information about a dedicated IP address, including the name of the dedicated IP
+ *             pool that it's associated with, as well information about the automatic warm-up process
+ *             for the address.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESv2Client, GetDedicatedIpCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, GetDedicatedIpCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new GetDedicatedIpCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetDedicatedIpCommandInput} for command's `input` shape.
+ * @see {@link GetDedicatedIpCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetDedicatedIpCommand extends $Command<GetDedicatedIpCommandInput, GetDedicatedIpCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: GetDedicatedIpCommandInput;
+    constructor(input: GetDedicatedIpCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDedicatedIpCommandInput, GetDedicatedIpCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetDedicatedIpsCommand.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 { GetDedicatedIpsRequest, GetDedicatedIpsResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface GetDedicatedIpsCommandInput extends GetDedicatedIpsRequest {
+}
+export interface GetDedicatedIpsCommandOutput extends GetDedicatedIpsResponse, __MetadataBearer {
+}
+/**
+ * <p>List the dedicated IP addresses that are associated with your Amazon Web Services
+ *             account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESv2Client, GetDedicatedIpsCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, GetDedicatedIpsCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new GetDedicatedIpsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetDedicatedIpsCommandInput} for command's `input` shape.
+ * @see {@link GetDedicatedIpsCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetDedicatedIpsCommand extends $Command<GetDedicatedIpsCommandInput, GetDedicatedIpsCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: GetDedicatedIpsCommandInput;
+    constructor(input: GetDedicatedIpsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDedicatedIpsCommandInput, GetDedicatedIpsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetDeliverabilityDashboardOptionsCommand.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 { GetDeliverabilityDashboardOptionsRequest, GetDeliverabilityDashboardOptionsResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface GetDeliverabilityDashboardOptionsCommandInput extends GetDeliverabilityDashboardOptionsRequest {
+}
+export interface GetDeliverabilityDashboardOptionsCommandOutput extends GetDeliverabilityDashboardOptionsResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieve information about the status of the Deliverability dashboard for your account. When
+ *             the Deliverability dashboard is enabled, you gain access to reputation, deliverability, and other
+ *             metrics for the domains that you use to send email. You also gain the ability to perform
+ *             predictive inbox placement tests.</p>
+ *
+ *         <p>When you use the Deliverability dashboard, you pay a monthly subscription charge, in addition
+ *             to any other fees that you accrue by using Amazon SES and other Amazon Web Services services. For more
+ *             information about the features and cost of a Deliverability dashboard subscription, see <a href="http://aws.amazon.com/ses/pricing/">Amazon SES Pricing</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESv2Client, GetDeliverabilityDashboardOptionsCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, GetDeliverabilityDashboardOptionsCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new GetDeliverabilityDashboardOptionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetDeliverabilityDashboardOptionsCommandInput} for command's `input` shape.
+ * @see {@link GetDeliverabilityDashboardOptionsCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetDeliverabilityDashboardOptionsCommand extends $Command<GetDeliverabilityDashboardOptionsCommandInput, GetDeliverabilityDashboardOptionsCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: GetDeliverabilityDashboardOptionsCommandInput;
+    constructor(input: GetDeliverabilityDashboardOptionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDeliverabilityDashboardOptionsCommandInput, GetDeliverabilityDashboardOptionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetDeliverabilityTestReportCommand.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 { GetDeliverabilityTestReportRequest, GetDeliverabilityTestReportResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface GetDeliverabilityTestReportCommandInput extends GetDeliverabilityTestReportRequest {
+}
+export interface GetDeliverabilityTestReportCommandOutput extends GetDeliverabilityTestReportResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieve the results of a predictive inbox placement test.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESv2Client, GetDeliverabilityTestReportCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, GetDeliverabilityTestReportCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new GetDeliverabilityTestReportCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetDeliverabilityTestReportCommandInput} for command's `input` shape.
+ * @see {@link GetDeliverabilityTestReportCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetDeliverabilityTestReportCommand extends $Command<GetDeliverabilityTestReportCommandInput, GetDeliverabilityTestReportCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: GetDeliverabilityTestReportCommandInput;
+    constructor(input: GetDeliverabilityTestReportCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDeliverabilityTestReportCommandInput, GetDeliverabilityTestReportCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetDomainDeliverabilityCampaignCommand.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 { GetDomainDeliverabilityCampaignRequest, GetDomainDeliverabilityCampaignResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface GetDomainDeliverabilityCampaignCommandInput extends GetDomainDeliverabilityCampaignRequest {
+}
+export interface GetDomainDeliverabilityCampaignCommandOutput extends GetDomainDeliverabilityCampaignResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieve all the deliverability data for a specific campaign. This data is available
+ *             for a campaign only if the campaign sent email by using a domain that the
+ *             Deliverability dashboard is enabled for.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESv2Client, GetDomainDeliverabilityCampaignCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, GetDomainDeliverabilityCampaignCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new GetDomainDeliverabilityCampaignCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetDomainDeliverabilityCampaignCommandInput} for command's `input` shape.
+ * @see {@link GetDomainDeliverabilityCampaignCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetDomainDeliverabilityCampaignCommand extends $Command<GetDomainDeliverabilityCampaignCommandInput, GetDomainDeliverabilityCampaignCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: GetDomainDeliverabilityCampaignCommandInput;
+    constructor(input: GetDomainDeliverabilityCampaignCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDomainDeliverabilityCampaignCommandInput, GetDomainDeliverabilityCampaignCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetDomainStatisticsReportCommand.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 { GetDomainStatisticsReportRequest, GetDomainStatisticsReportResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface GetDomainStatisticsReportCommandInput extends GetDomainStatisticsReportRequest {
+}
+export interface GetDomainStatisticsReportCommandOutput extends GetDomainStatisticsReportResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieve inbox placement and engagement rates for the domains that you use to send
+ *             email.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESv2Client, GetDomainStatisticsReportCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, GetDomainStatisticsReportCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new GetDomainStatisticsReportCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetDomainStatisticsReportCommandInput} for command's `input` shape.
+ * @see {@link GetDomainStatisticsReportCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetDomainStatisticsReportCommand extends $Command<GetDomainStatisticsReportCommandInput, GetDomainStatisticsReportCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: GetDomainStatisticsReportCommandInput;
+    constructor(input: GetDomainStatisticsReportCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDomainStatisticsReportCommandInput, GetDomainStatisticsReportCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetEmailIdentityCommand.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 { GetEmailIdentityRequest, GetEmailIdentityResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface GetEmailIdentityCommandInput extends GetEmailIdentityRequest {
+}
+export interface GetEmailIdentityCommandOutput extends GetEmailIdentityResponse, __MetadataBearer {
+}
+/**
+ * <p>Provides information about a specific identity, including the identity's verification
+ *             status, sending authorization policies, its DKIM authentication status, and its custom
+ *             Mail-From settings.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESv2Client, GetEmailIdentityCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, GetEmailIdentityCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new GetEmailIdentityCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetEmailIdentityCommandInput} for command's `input` shape.
+ * @see {@link GetEmailIdentityCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetEmailIdentityCommand extends $Command<GetEmailIdentityCommandInput, GetEmailIdentityCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: GetEmailIdentityCommandInput;
+    constructor(input: GetEmailIdentityCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEmailIdentityCommandInput, GetEmailIdentityCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

package/dist-types/ts3.4/commands/GetImportJobCommand.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 { GetImportJobRequest, GetImportJobResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface GetImportJobCommandInput extends GetImportJobRequest {
+}
+export interface GetImportJobCommandOutput extends GetImportJobResponse, __MetadataBearer {
+}
+/**
+ * <p>Provides information about an import job.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESv2Client, GetImportJobCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, GetImportJobCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new GetImportJobCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetImportJobCommandInput} for command's `input` shape.
+ * @see {@link GetImportJobCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetImportJobCommand extends $Command<GetImportJobCommandInput, GetImportJobCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: GetImportJobCommandInput;
+    constructor(input: GetImportJobCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetImportJobCommandInput, GetImportJobCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetSuppressedDestinationCommand.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 { GetSuppressedDestinationRequest, GetSuppressedDestinationResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface GetSuppressedDestinationCommandInput extends GetSuppressedDestinationRequest {
+}
+export interface GetSuppressedDestinationCommandOutput extends GetSuppressedDestinationResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves information about a specific email address that's on 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, GetSuppressedDestinationCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, GetSuppressedDestinationCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new GetSuppressedDestinationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSuppressedDestinationCommandInput} for command's `input` shape.
+ * @see {@link GetSuppressedDestinationCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetSuppressedDestinationCommand extends $Command<GetSuppressedDestinationCommandInput, GetSuppressedDestinationCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: GetSuppressedDestinationCommandInput;
+    constructor(input: GetSuppressedDestinationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSuppressedDestinationCommandInput, GetSuppressedDestinationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListConfigurationSetsCommand.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 { ListConfigurationSetsRequest, ListConfigurationSetsResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface ListConfigurationSetsCommandInput extends ListConfigurationSetsRequest {
+}
+export interface ListConfigurationSetsCommandOutput extends ListConfigurationSetsResponse, __MetadataBearer {
+}
+/**
+ * <p>List all of the configuration sets associated with your account in the current
+ *             region.</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, ListConfigurationSetsCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, ListConfigurationSetsCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(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 SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListConfigurationSetsCommand extends $Command<ListConfigurationSetsCommandInput, ListConfigurationSetsCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: ListConfigurationSetsCommandInput;
+    constructor(input: ListConfigurationSetsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListConfigurationSetsCommandInput, ListConfigurationSetsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListContactListsCommand.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 { ListContactListsRequest, ListContactListsResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESv2ClientResolvedConfig } from "../SESv2Client";
+export interface ListContactListsCommandInput extends ListContactListsRequest {
+}
+export interface ListContactListsCommandOutput extends ListContactListsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists all of the contact lists available.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESv2Client, ListContactListsCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
+ * // const { SESv2Client, ListContactListsCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
+ * const client = new SESv2Client(config);
+ * const command = new ListContactListsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListContactListsCommandInput} for command's `input` shape.
+ * @see {@link ListContactListsCommandOutput} for command's `response` shape.
+ * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListContactListsCommand extends $Command<ListContactListsCommandInput, ListContactListsCommandOutput, SESv2ClientResolvedConfig> {
+    readonly input: ListContactListsCommandInput;
+    constructor(input: ListContactListsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListContactListsCommandInput, ListContactListsCommandOutput>;
+    private serialize;
+    private deserialize;
+}