@aws-sdk/client-sqs 3.296.0 → 3.297.0

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { AddPermissionRequest } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, SQSClientResolvedConfig } from "../SQSClient";
 /**
+ * @public
+ *
  * The input for {@link AddPermissionCommand}.
  */
 export interface AddPermissionCommandInput extends AddPermissionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link AddPermissionCommand}.
  */
 export interface AddPermissionCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Adds a permission to a queue for a specific
  *       <a href="https://docs.aws.amazon.com/general/latest/gr/glos-chap.html#P">principal</a>.
  *       This allows sharing access to the queue.</p>
@@ -64,6 +69,8 @@ export interface AddPermissionCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param AddPermissionCommandInput - {@link AddPermissionCommandInput}
+ * @returns {@link AddPermissionCommandOutput}
  * @see {@link AddPermissionCommandInput} for command's `input` shape.
  * @see {@link AddPermissionCommandOutput} for command's `response` shape.
  * @see {@link SQSClientResolvedConfig | config} for SQSClient's `config` shape.
@@ -79,11 +86,20 @@ export interface AddPermissionCommandOutput extends __MetadataBearer {
 export declare class AddPermissionCommand extends $Command<AddPermissionCommandInput, AddPermissionCommandOutput, SQSClientResolvedConfig> {
     readonly input: AddPermissionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: AddPermissionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SQSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AddPermissionCommandInput, AddPermissionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { ChangeMessageVisibilityBatchRequest, ChangeMessageVisibilityBatchResult } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, SQSClientResolvedConfig } from "../SQSClient";
 /**
+ * @public
+ *
  * The input for {@link ChangeMessageVisibilityBatchCommand}.
  */
 export interface ChangeMessageVisibilityBatchCommandInput extends ChangeMessageVisibilityBatchRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ChangeMessageVisibilityBatchCommand}.
  */
 export interface ChangeMessageVisibilityBatchCommandOutput extends ChangeMessageVisibilityBatchResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Changes the visibility timeout of multiple messages. This is a batch version of <code>
  *                <a>ChangeMessageVisibility</a>.</code> The result of the action on each message is reported individually in the response.
  *           You can send up to 10 <code>
@@ -39,6 +44,8 @@ export interface ChangeMessageVisibilityBatchCommandOutput extends ChangeMessage
  * const response = await client.send(command);
  * ```
  *
+ * @param ChangeMessageVisibilityBatchCommandInput - {@link ChangeMessageVisibilityBatchCommandInput}
+ * @returns {@link ChangeMessageVisibilityBatchCommandOutput}
  * @see {@link ChangeMessageVisibilityBatchCommandInput} for command's `input` shape.
  * @see {@link ChangeMessageVisibilityBatchCommandOutput} for command's `response` shape.
  * @see {@link SQSClientResolvedConfig | config} for SQSClient's `config` shape.
@@ -60,11 +67,20 @@ export interface ChangeMessageVisibilityBatchCommandOutput extends ChangeMessage
 export declare class ChangeMessageVisibilityBatchCommand extends $Command<ChangeMessageVisibilityBatchCommandInput, ChangeMessageVisibilityBatchCommandOutput, SQSClientResolvedConfig> {
     readonly input: ChangeMessageVisibilityBatchCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ChangeMessageVisibilityBatchCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SQSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ChangeMessageVisibilityBatchCommandInput, ChangeMessageVisibilityBatchCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { ChangeMessageVisibilityRequest } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, SQSClientResolvedConfig } from "../SQSClient";
 /**
+ * @public
+ *
  * The input for {@link ChangeMessageVisibilityCommand}.
  */
 export interface ChangeMessageVisibilityCommandInput extends ChangeMessageVisibilityRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ChangeMessageVisibilityCommand}.
  */
 export interface ChangeMessageVisibilityCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Changes the visibility timeout of a specified message in a queue to a new value. The
  *             default visibility timeout for a message is 30 seconds. The minimum is 0 seconds. The
  *             maximum is 12 hours. For more information, see <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html">Visibility Timeout</a> in the <i>Amazon SQS Developer Guide</i>.</p>
@@ -58,6 +63,8 @@ export interface ChangeMessageVisibilityCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param ChangeMessageVisibilityCommandInput - {@link ChangeMessageVisibilityCommandInput}
+ * @returns {@link ChangeMessageVisibilityCommandOutput}
  * @see {@link ChangeMessageVisibilityCommandInput} for command's `input` shape.
  * @see {@link ChangeMessageVisibilityCommandOutput} for command's `response` shape.
  * @see {@link SQSClientResolvedConfig | config} for SQSClient's `config` shape.
@@ -73,11 +80,20 @@ export interface ChangeMessageVisibilityCommandOutput extends __MetadataBearer {
 export declare class ChangeMessageVisibilityCommand extends $Command<ChangeMessageVisibilityCommandInput, ChangeMessageVisibilityCommandOutput, SQSClientResolvedConfig> {
     readonly input: ChangeMessageVisibilityCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ChangeMessageVisibilityCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SQSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ChangeMessageVisibilityCommandInput, ChangeMessageVisibilityCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateQueueRequest, CreateQueueResult } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, SQSClientResolvedConfig } from "../SQSClient";
 /**
+ * @public
+ *
  * The input for {@link CreateQueueCommand}.
  */
 export interface CreateQueueCommandInput extends CreateQueueRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateQueueCommand}.
  */
 export interface CreateQueueCommandOutput extends CreateQueueResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a new standard or FIFO queue. You can pass one or more attributes in
  *             the request. Keep the following in mind:</p>
  *          <ul>
@@ -76,6 +81,8 @@ export interface CreateQueueCommandOutput extends CreateQueueResult, __MetadataB
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateQueueCommandInput - {@link CreateQueueCommandInput}
+ * @returns {@link CreateQueueCommandOutput}
  * @see {@link CreateQueueCommandInput} for command's `input` shape.
  * @see {@link CreateQueueCommandOutput} for command's `response` shape.
  * @see {@link SQSClientResolvedConfig | config} for SQSClient's `config` shape.
@@ -93,11 +100,20 @@ export interface CreateQueueCommandOutput extends CreateQueueResult, __MetadataB
 export declare class CreateQueueCommand extends $Command<CreateQueueCommandInput, CreateQueueCommandOutput, SQSClientResolvedConfig> {
     readonly input: CreateQueueCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateQueueCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SQSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateQueueCommandInput, CreateQueueCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteMessageBatchRequest, DeleteMessageBatchResult } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, SQSClientResolvedConfig } from "../SQSClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteMessageBatchCommand}.
  */
 export interface DeleteMessageBatchCommandInput extends DeleteMessageBatchRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteMessageBatchCommand}.
  */
 export interface DeleteMessageBatchCommandOutput extends DeleteMessageBatchResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes up to ten messages from the specified queue. This is a batch version of <code>
  *                <a>DeleteMessage</a>.</code> The result of the action on each message is reported individually in the response.</p>
  *          <important>
@@ -36,6 +41,8 @@ export interface DeleteMessageBatchCommandOutput extends DeleteMessageBatchResul
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteMessageBatchCommandInput - {@link DeleteMessageBatchCommandInput}
+ * @returns {@link DeleteMessageBatchCommandOutput}
  * @see {@link DeleteMessageBatchCommandInput} for command's `input` shape.
  * @see {@link DeleteMessageBatchCommandOutput} for command's `response` shape.
  * @see {@link SQSClientResolvedConfig | config} for SQSClient's `config` shape.
@@ -57,11 +64,20 @@ export interface DeleteMessageBatchCommandOutput extends DeleteMessageBatchResul
 export declare class DeleteMessageBatchCommand extends $Command<DeleteMessageBatchCommandInput, DeleteMessageBatchCommandOutput, SQSClientResolvedConfig> {
     readonly input: DeleteMessageBatchCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteMessageBatchCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SQSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteMessageBatchCommandInput, DeleteMessageBatchCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteMessageRequest } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, SQSClientResolvedConfig } from "../SQSClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteMessageCommand}.
  */
 export interface DeleteMessageCommandInput extends DeleteMessageRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteMessageCommand}.
  */
 export interface DeleteMessageCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the specified message from the specified queue. To select the message to
  *             delete, use the <code>ReceiptHandle</code> of the message (<i>not</i> the
  *                 <code>MessageId</code> which you receive when you send the message). Amazon SQS can
@@ -44,6 +49,8 @@ export interface DeleteMessageCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteMessageCommandInput - {@link DeleteMessageCommandInput}
+ * @returns {@link DeleteMessageCommandOutput}
  * @see {@link DeleteMessageCommandInput} for command's `input` shape.
  * @see {@link DeleteMessageCommandOutput} for command's `response` shape.
  * @see {@link SQSClientResolvedConfig | config} for SQSClient's `config` shape.
@@ -59,11 +66,20 @@ export interface DeleteMessageCommandOutput extends __MetadataBearer {
 export declare class DeleteMessageCommand extends $Command<DeleteMessageCommandInput, DeleteMessageCommandOutput, SQSClientResolvedConfig> {
     readonly input: DeleteMessageCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteMessageCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SQSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteMessageCommandInput, DeleteMessageCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteQueueRequest } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, SQSClientResolvedConfig } from "../SQSClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteQueueCommand}.
  */
 export interface DeleteQueueCommandInput extends DeleteQueueRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteQueueCommand}.
  */
 export interface DeleteQueueCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the queue specified by the <code>QueueUrl</code>, regardless of the queue's contents.</p>
  *          <important>
  *             <p>Be careful with the <code>DeleteQueue</code> action: When you delete a queue, any messages in the queue are no longer available.
@@ -39,6 +44,8 @@ export interface DeleteQueueCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteQueueCommandInput - {@link DeleteQueueCommandInput}
+ * @returns {@link DeleteQueueCommandOutput}
  * @see {@link DeleteQueueCommandInput} for command's `input` shape.
  * @see {@link DeleteQueueCommandOutput} for command's `response` shape.
  * @see {@link SQSClientResolvedConfig | config} for SQSClient's `config` shape.
@@ -48,11 +55,20 @@ export interface DeleteQueueCommandOutput extends __MetadataBearer {
 export declare class DeleteQueueCommand extends $Command<DeleteQueueCommandInput, DeleteQueueCommandOutput, SQSClientResolvedConfig> {
     readonly input: DeleteQueueCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteQueueCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SQSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteQueueCommandInput, DeleteQueueCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { GetQueueAttributesRequest, GetQueueAttributesResult } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, SQSClientResolvedConfig } from "../SQSClient";
 /**
+ * @public
+ *
  * The input for {@link GetQueueAttributesCommand}.
  */
 export interface GetQueueAttributesCommandInput extends GetQueueAttributesRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link GetQueueAttributesCommand}.
  */
 export interface GetQueueAttributesCommandOutput extends GetQueueAttributesResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Gets attributes for the specified queue.</p>
  *          <note>
  *             <p>To determine whether a queue is <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html">FIFO</a>, you can check whether <code>QueueName</code> ends with the <code>.fifo</code> suffix.</p>
@@ -28,6 +33,8 @@ export interface GetQueueAttributesCommandOutput extends GetQueueAttributesResul
  * const response = await client.send(command);
  * ```
  *
+ * @param GetQueueAttributesCommandInput - {@link GetQueueAttributesCommandInput}
+ * @returns {@link GetQueueAttributesCommandOutput}
  * @see {@link GetQueueAttributesCommandInput} for command's `input` shape.
  * @see {@link GetQueueAttributesCommandOutput} for command's `response` shape.
  * @see {@link SQSClientResolvedConfig | config} for SQSClient's `config` shape.
@@ -40,11 +47,20 @@ export interface GetQueueAttributesCommandOutput extends GetQueueAttributesResul
 export declare class GetQueueAttributesCommand extends $Command<GetQueueAttributesCommandInput, GetQueueAttributesCommandOutput, SQSClientResolvedConfig> {
     readonly input: GetQueueAttributesCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: GetQueueAttributesCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SQSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetQueueAttributesCommandInput, GetQueueAttributesCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { GetQueueUrlRequest, GetQueueUrlResult } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, SQSClientResolvedConfig } from "../SQSClient";
 /**
+ * @public
+ *
  * The input for {@link GetQueueUrlCommand}.
  */
 export interface GetQueueUrlCommandInput extends GetQueueUrlRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link GetQueueUrlCommand}.
  */
 export interface GetQueueUrlCommandOutput extends GetQueueUrlResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Returns the URL of an existing Amazon SQS queue.</p>
  *          <p>To access a queue that belongs to another AWS account, use the <code>QueueOwnerAWSAccountId</code> parameter to specify the account ID of the queue's owner. The queue's owner must grant you permission to access the queue.
  *           For more information about shared queue access, see <code>
@@ -30,6 +35,8 @@ export interface GetQueueUrlCommandOutput extends GetQueueUrlResult, __MetadataB
  * const response = await client.send(command);
  * ```
  *
+ * @param GetQueueUrlCommandInput - {@link GetQueueUrlCommandInput}
+ * @returns {@link GetQueueUrlCommandOutput}
  * @see {@link GetQueueUrlCommandInput} for command's `input` shape.
  * @see {@link GetQueueUrlCommandOutput} for command's `response` shape.
  * @see {@link SQSClientResolvedConfig | config} for SQSClient's `config` shape.
@@ -42,11 +49,20 @@ export interface GetQueueUrlCommandOutput extends GetQueueUrlResult, __MetadataB
 export declare class GetQueueUrlCommand extends $Command<GetQueueUrlCommandInput, GetQueueUrlCommandOutput, SQSClientResolvedConfig> {
     readonly input: GetQueueUrlCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: GetQueueUrlCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SQSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetQueueUrlCommandInput, GetQueueUrlCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { ListDeadLetterSourceQueuesRequest, ListDeadLetterSourceQueuesResult } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, SQSClientResolvedConfig } from "../SQSClient";
 /**
+ * @public
+ *
  * The input for {@link ListDeadLetterSourceQueuesCommand}.
  */
 export interface ListDeadLetterSourceQueuesCommandInput extends ListDeadLetterSourceQueuesRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ListDeadLetterSourceQueuesCommand}.
  */
 export interface ListDeadLetterSourceQueuesCommandOutput extends ListDeadLetterSourceQueuesResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Returns a list of your queues that have the <code>RedrivePolicy</code> queue attribute configured with a dead-letter queue.</p>
  *          <p> The <code>ListDeadLetterSourceQueues</code> methods supports
  *           pagination. Set parameter <code>MaxResults</code> in the request to specify the maximum number of
@@ -35,6 +40,8 @@ export interface ListDeadLetterSourceQueuesCommandOutput extends ListDeadLetterS
  * const response = await client.send(command);
  * ```
  *
+ * @param ListDeadLetterSourceQueuesCommandInput - {@link ListDeadLetterSourceQueuesCommandInput}
+ * @returns {@link ListDeadLetterSourceQueuesCommandOutput}
  * @see {@link ListDeadLetterSourceQueuesCommandInput} for command's `input` shape.
  * @see {@link ListDeadLetterSourceQueuesCommandOutput} for command's `response` shape.
  * @see {@link SQSClientResolvedConfig | config} for SQSClient's `config` shape.
@@ -47,11 +54,20 @@ export interface ListDeadLetterSourceQueuesCommandOutput extends ListDeadLetterS
 export declare class ListDeadLetterSourceQueuesCommand extends $Command<ListDeadLetterSourceQueuesCommandInput, ListDeadLetterSourceQueuesCommandOutput, SQSClientResolvedConfig> {
     readonly input: ListDeadLetterSourceQueuesCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ListDeadLetterSourceQueuesCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SQSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDeadLetterSourceQueuesCommandInput, ListDeadLetterSourceQueuesCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { ListQueueTagsRequest, ListQueueTagsResult } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, SQSClientResolvedConfig } from "../SQSClient";
 /**
+ * @public
+ *
  * The input for {@link ListQueueTagsCommand}.
  */
 export interface ListQueueTagsCommandInput extends ListQueueTagsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ListQueueTagsCommand}.
  */
 export interface ListQueueTagsCommandOutput extends ListQueueTagsResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>List all cost allocation tags added to the specified Amazon SQS queue. For an overview, see <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-queue-tags.html">Tagging
  * Your Amazon SQS Queues</a> in the <i>Amazon SQS Developer Guide</i>.</p>
  *         <note>
@@ -31,6 +36,8 @@ export interface ListQueueTagsCommandOutput extends ListQueueTagsResult, __Metad
  * const response = await client.send(command);
  * ```
  *
+ * @param ListQueueTagsCommandInput - {@link ListQueueTagsCommandInput}
+ * @returns {@link ListQueueTagsCommandOutput}
  * @see {@link ListQueueTagsCommandInput} for command's `input` shape.
  * @see {@link ListQueueTagsCommandOutput} for command's `response` shape.
  * @see {@link SQSClientResolvedConfig | config} for SQSClient's `config` shape.
@@ -40,11 +47,20 @@ export interface ListQueueTagsCommandOutput extends ListQueueTagsResult, __Metad
 export declare class ListQueueTagsCommand extends $Command<ListQueueTagsCommandInput, ListQueueTagsCommandOutput, SQSClientResolvedConfig> {
     readonly input: ListQueueTagsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ListQueueTagsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SQSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListQueueTagsCommandInput, ListQueueTagsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { ListQueuesRequest, ListQueuesResult } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, SQSClientResolvedConfig } from "../SQSClient";
 /**
+ * @public
+ *
  * The input for {@link ListQueuesCommand}.
  */
 export interface ListQueuesCommandInput extends ListQueuesRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ListQueuesCommand}.
  */
 export interface ListQueuesCommandOutput extends ListQueuesResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Returns a list of your queues in the current region. The response includes a maximum of 1,000 results. If you specify a value for the optional
  *           <code>QueueNamePrefix</code> parameter, only queues with a name that begins with the specified value are returned.</p>
  *          <p> The <code>listQueues</code> methods supports
@@ -38,6 +43,8 @@ export interface ListQueuesCommandOutput extends ListQueuesResult, __MetadataBea
  * const response = await client.send(command);
  * ```
  *
+ * @param ListQueuesCommandInput - {@link ListQueuesCommandInput}
+ * @returns {@link ListQueuesCommandOutput}
  * @see {@link ListQueuesCommandInput} for command's `input` shape.
  * @see {@link ListQueuesCommandOutput} for command's `response` shape.
  * @see {@link SQSClientResolvedConfig | config} for SQSClient's `config` shape.
@@ -47,11 +54,20 @@ export interface ListQueuesCommandOutput extends ListQueuesResult, __MetadataBea
 export declare class ListQueuesCommand extends $Command<ListQueuesCommandInput, ListQueuesCommandOutput, SQSClientResolvedConfig> {
     readonly input: ListQueuesCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ListQueuesCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SQSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListQueuesCommandInput, ListQueuesCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { PurgeQueueRequest } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, SQSClientResolvedConfig } from "../SQSClient";
 /**
+ * @public
+ *
  * The input for {@link PurgeQueueCommand}.
  */
 export interface PurgeQueueCommandInput extends PurgeQueueRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link PurgeQueueCommand}.
  */
 export interface PurgeQueueCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the messages in a queue specified by the <code>QueueURL</code>
  *             parameter.</p>
  *
@@ -38,6 +43,8 @@ export interface PurgeQueueCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param PurgeQueueCommandInput - {@link PurgeQueueCommandInput}
+ * @returns {@link PurgeQueueCommandOutput}
  * @see {@link PurgeQueueCommandInput} for command's `input` shape.
  * @see {@link PurgeQueueCommandOutput} for command's `response` shape.
  * @see {@link SQSClientResolvedConfig | config} for SQSClient's `config` shape.
@@ -53,11 +60,20 @@ export interface PurgeQueueCommandOutput extends __MetadataBearer {
 export declare class PurgeQueueCommand extends $Command<PurgeQueueCommandInput, PurgeQueueCommandOutput, SQSClientResolvedConfig> {
     readonly input: PurgeQueueCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: PurgeQueueCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SQSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PurgeQueueCommandInput, PurgeQueueCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }