@aws-sdk/client-ses 3.36.0 → 3.39.0

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

@@ -6,32 +6,11 @@ export interface DeleteCustomVerificationEmailTemplateCommandInput extends Delet
 }
 export interface DeleteCustomVerificationEmailTemplateCommandOutput extends __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/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, DeleteCustomVerificationEmailTemplateCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, DeleteCustomVerificationEmailTemplateCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(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 SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteCustomVerificationEmailTemplateCommand extends $Command<DeleteCustomVerificationEmailTemplateCommandInput, DeleteCustomVerificationEmailTemplateCommandOutput, SESClientResolvedConfig> {
     readonly input: DeleteCustomVerificationEmailTemplateCommandInput;
     constructor(input: DeleteCustomVerificationEmailTemplateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCustomVerificationEmailTemplateCommandInput, DeleteCustomVerificationEmailTemplateCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DeleteIdentityCommandInput extends DeleteIdentityRequest {
 }
 export interface DeleteIdentityCommandOutput extends DeleteIdentityResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified identity (an email address or a domain) from the list of
- *             verified identities.</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, DeleteIdentityCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, DeleteIdentityCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new DeleteIdentityCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteIdentityCommandInput} for command's `input` shape.
- * @see {@link DeleteIdentityCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteIdentityCommand extends $Command<DeleteIdentityCommandInput, DeleteIdentityCommandOutput, SESClientResolvedConfig> {
     readonly input: DeleteIdentityCommandInput;
     constructor(input: DeleteIdentityCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteIdentityCommandInput, DeleteIdentityCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,40 +6,11 @@ export interface DeleteIdentityPolicyCommandInput extends DeleteIdentityPolicyRe
 }
 export interface DeleteIdentityPolicyCommandOutput extends DeleteIdentityPolicyResponse, __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 { SESClient, DeleteIdentityPolicyCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, DeleteIdentityPolicyCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new DeleteIdentityPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteIdentityPolicyCommandInput} for command's `input` shape.
- * @see {@link DeleteIdentityPolicyCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteIdentityPolicyCommand extends $Command<DeleteIdentityPolicyCommandInput, DeleteIdentityPolicyCommandOutput, SESClientResolvedConfig> {
     readonly input: DeleteIdentityPolicyCommandInput;
     constructor(input: DeleteIdentityPolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteIdentityPolicyCommandInput, DeleteIdentityPolicyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DeleteReceiptFilterCommandInput extends DeleteReceiptFilterRequ
 }
 export interface DeleteReceiptFilterCommandOutput extends DeleteReceiptFilterResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified IP address filter.</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, DeleteReceiptFilterCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, DeleteReceiptFilterCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new DeleteReceiptFilterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteReceiptFilterCommandInput} for command's `input` shape.
- * @see {@link DeleteReceiptFilterCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteReceiptFilterCommand extends $Command<DeleteReceiptFilterCommandInput, DeleteReceiptFilterCommandOutput, SESClientResolvedConfig> {
     readonly input: DeleteReceiptFilterCommandInput;
     constructor(input: DeleteReceiptFilterCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteReceiptFilterCommandInput, DeleteReceiptFilterCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DeleteReceiptRuleCommandInput extends DeleteReceiptRuleRequest
 }
 export interface DeleteReceiptRuleCommandOutput extends DeleteReceiptRuleResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified receipt rule.</p>
- *         <p>For information about managing receipt rules, see the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/receiving-email-managing-receipt-rules.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, DeleteReceiptRuleCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, DeleteReceiptRuleCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new DeleteReceiptRuleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteReceiptRuleCommandInput} for command's `input` shape.
- * @see {@link DeleteReceiptRuleCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteReceiptRuleCommand extends $Command<DeleteReceiptRuleCommandInput, DeleteReceiptRuleCommandOutput, SESClientResolvedConfig> {
     readonly input: DeleteReceiptRuleCommandInput;
     constructor(input: DeleteReceiptRuleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteReceiptRuleCommandInput, DeleteReceiptRuleCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface DeleteReceiptRuleSetCommandInput extends DeleteReceiptRuleSetRe
 }
 export interface DeleteReceiptRuleSetCommandOutput extends DeleteReceiptRuleSetResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified receipt rule set and all of the receipt rules it
- *             contains.</p>
- *         <note>
- *             <p>The currently active rule set cannot be deleted.</p>
- *         </note>
- *         <p>For information about managing receipt rule sets, see the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/receiving-email-managing-receipt-rule-sets.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, DeleteReceiptRuleSetCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, DeleteReceiptRuleSetCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new DeleteReceiptRuleSetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteReceiptRuleSetCommandInput} for command's `input` shape.
- * @see {@link DeleteReceiptRuleSetCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteReceiptRuleSetCommand extends $Command<DeleteReceiptRuleSetCommandInput, DeleteReceiptRuleSetCommandOutput, SESClientResolvedConfig> {
     readonly input: DeleteReceiptRuleSetCommandInput;
     constructor(input: DeleteReceiptRuleSetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteReceiptRuleSetCommandInput, DeleteReceiptRuleSetCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DeleteTemplateCommandInput extends DeleteTemplateRequest {
 }
 export interface DeleteTemplateCommandOutput extends DeleteTemplateResponse, __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 { SESClient, DeleteTemplateCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, DeleteTemplateCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new DeleteTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteTemplateCommandInput} for command's `input` shape.
- * @see {@link DeleteTemplateCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteTemplateCommand extends $Command<DeleteTemplateCommandInput, DeleteTemplateCommandOutput, SESClientResolvedConfig> {
     readonly input: DeleteTemplateCommandInput;
     constructor(input: DeleteTemplateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteTemplateCommandInput, DeleteTemplateCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DeleteVerifiedEmailAddressCommandInput extends DeleteVerifiedEm
 }
 export interface DeleteVerifiedEmailAddressCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deprecated. Use the <code>DeleteIdentity</code> operation to delete email addresses
- *             and domains.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESClient, DeleteVerifiedEmailAddressCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, DeleteVerifiedEmailAddressCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new DeleteVerifiedEmailAddressCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteVerifiedEmailAddressCommandInput} for command's `input` shape.
- * @see {@link DeleteVerifiedEmailAddressCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteVerifiedEmailAddressCommand extends $Command<DeleteVerifiedEmailAddressCommandInput, DeleteVerifiedEmailAddressCommandOutput, SESClientResolvedConfig> {
     readonly input: DeleteVerifiedEmailAddressCommandInput;
     constructor(input: DeleteVerifiedEmailAddressCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteVerifiedEmailAddressCommandInput, DeleteVerifiedEmailAddressCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DescribeActiveReceiptRuleSetCommandInput extends DescribeActive
 }
 export interface DescribeActiveReceiptRuleSetCommandOutput extends DescribeActiveReceiptRuleSetResponse, __MetadataBearer {
 }
-/**
- * <p>Returns the metadata and receipt rules for the receipt rule set that is currently
- *             active.</p>
- *         <p>For information about setting up receipt rule sets, see the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/receiving-email-receipt-rule-set.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, DescribeActiveReceiptRuleSetCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, DescribeActiveReceiptRuleSetCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new DescribeActiveReceiptRuleSetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeActiveReceiptRuleSetCommandInput} for command's `input` shape.
- * @see {@link DescribeActiveReceiptRuleSetCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeActiveReceiptRuleSetCommand extends $Command<DescribeActiveReceiptRuleSetCommandInput, DescribeActiveReceiptRuleSetCommandOutput, SESClientResolvedConfig> {
     readonly input: DescribeActiveReceiptRuleSetCommandInput;
     constructor(input: DescribeActiveReceiptRuleSetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeActiveReceiptRuleSetCommandInput, DescribeActiveReceiptRuleSetCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DescribeConfigurationSetCommandInput extends DescribeConfigurat
 }
 export interface DescribeConfigurationSetCommandOutput extends DescribeConfigurationSetResponse, __MetadataBearer {
 }
-/**
- * <p>Returns the details of the specified configuration set. For information about using
- *             configuration sets, see the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/monitor-sending-activity.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, DescribeConfigurationSetCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, DescribeConfigurationSetCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new DescribeConfigurationSetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeConfigurationSetCommandInput} for command's `input` shape.
- * @see {@link DescribeConfigurationSetCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeConfigurationSetCommand extends $Command<DescribeConfigurationSetCommandInput, DescribeConfigurationSetCommandOutput, SESClientResolvedConfig> {
     readonly input: DescribeConfigurationSetCommandInput;
     constructor(input: DescribeConfigurationSetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeConfigurationSetCommandInput, DescribeConfigurationSetCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DescribeReceiptRuleCommandInput extends DescribeReceiptRuleRequ
 }
 export interface DescribeReceiptRuleCommandOutput extends DescribeReceiptRuleResponse, __MetadataBearer {
 }
-/**
- * <p>Returns the details of the specified receipt rule.</p>
- *         <p>For information about setting up receipt rules, see the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/receiving-email-receipt-rules.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, DescribeReceiptRuleCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, DescribeReceiptRuleCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new DescribeReceiptRuleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeReceiptRuleCommandInput} for command's `input` shape.
- * @see {@link DescribeReceiptRuleCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeReceiptRuleCommand extends $Command<DescribeReceiptRuleCommandInput, DescribeReceiptRuleCommandOutput, SESClientResolvedConfig> {
     readonly input: DescribeReceiptRuleCommandInput;
     constructor(input: DescribeReceiptRuleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeReceiptRuleCommandInput, DescribeReceiptRuleCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeReceiptRuleSetCommandInput extends DescribeReceiptRuleS
 }
 export interface DescribeReceiptRuleSetCommandOutput extends DescribeReceiptRuleSetResponse, __MetadataBearer {
 }
-/**
- * <p>Returns the details of the specified receipt rule set.</p>
- *         <p>For information about managing receipt rule sets, see the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/receiving-email-managing-receipt-rule-sets.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, DescribeReceiptRuleSetCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, DescribeReceiptRuleSetCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new DescribeReceiptRuleSetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeReceiptRuleSetCommandInput} for command's `input` shape.
- * @see {@link DescribeReceiptRuleSetCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeReceiptRuleSetCommand extends $Command<DescribeReceiptRuleSetCommandInput, DescribeReceiptRuleSetCommandOutput, SESClientResolvedConfig> {
     readonly input: DescribeReceiptRuleSetCommandInput;
     constructor(input: DescribeReceiptRuleSetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeReceiptRuleSetCommandInput, DescribeReceiptRuleSetCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface GetAccountSendingEnabledCommandInput {
 }
 export interface GetAccountSendingEnabledCommandOutput extends GetAccountSendingEnabledResponse, __MetadataBearer {
 }
-/**
- * <p>Returns the email sending status of the Amazon SES account for the current region.</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, GetAccountSendingEnabledCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, GetAccountSendingEnabledCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new GetAccountSendingEnabledCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetAccountSendingEnabledCommandInput} for command's `input` shape.
- * @see {@link GetAccountSendingEnabledCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetAccountSendingEnabledCommand extends $Command<GetAccountSendingEnabledCommandInput, GetAccountSendingEnabledCommandOutput, SESClientResolvedConfig> {
     readonly input: GetAccountSendingEnabledCommandInput;
     constructor(input: GetAccountSendingEnabledCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAccountSendingEnabledCommandInput, GetAccountSendingEnabledCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,32 +6,11 @@ export interface GetIdentityMailFromDomainAttributesCommandInput extends GetIden
 }
 export interface GetIdentityMailFromDomainAttributesCommandOutput extends GetIdentityMailFromDomainAttributesResponse, __MetadataBearer {
 }
-/**
- * <p>Returns the custom MAIL FROM attributes for a list of identities (email addresses :
- *             domains).</p>
- *         <p>This operation is throttled at one request per second and can only get custom MAIL
- *             FROM attributes for up to 100 identities at a time.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESClient, GetIdentityMailFromDomainAttributesCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, GetIdentityMailFromDomainAttributesCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new GetIdentityMailFromDomainAttributesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetIdentityMailFromDomainAttributesCommandInput} for command's `input` shape.
- * @see {@link GetIdentityMailFromDomainAttributesCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetIdentityMailFromDomainAttributesCommand extends $Command<GetIdentityMailFromDomainAttributesCommandInput, GetIdentityMailFromDomainAttributesCommandOutput, SESClientResolvedConfig> {
     readonly input: GetIdentityMailFromDomainAttributesCommandInput;
     constructor(input: GetIdentityMailFromDomainAttributesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetIdentityMailFromDomainAttributesCommandInput, GetIdentityMailFromDomainAttributesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface GetIdentityNotificationAttributesCommandInput extends GetIdenti
 }
 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;