@aws-sdk/client-glacier 3.35.0 → 3.36.0

package/src/commands/InitiateMultipartUploadCommand.ts

@@ -1,128 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { GlacierClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GlacierClient";
-import { InitiateMultipartUploadInput, InitiateMultipartUploadOutput } from "../models/models_0";
-import {
-  deserializeAws_restJson1InitiateMultipartUploadCommand,
-  serializeAws_restJson1InitiateMultipartUploadCommand,
-} from "../protocols/Aws_restJson1";
-
-export interface InitiateMultipartUploadCommandInput extends InitiateMultipartUploadInput {}
-export interface InitiateMultipartUploadCommandOutput extends InitiateMultipartUploadOutput, __MetadataBearer {}
-
-/**
- * <p>This operation initiates a multipart upload. Amazon S3 Glacier creates a multipart
- *          upload resource and returns its ID in the response. The multipart upload ID is used in
- *          subsequent requests to upload parts of an archive (see <a>UploadMultipartPart</a>).</p>
- *
- *          <p>When you initiate a multipart upload, you specify the part size in number of bytes.
- *          The part size must be a megabyte (1024 KB) multiplied by a power of 2-for example, 1048576
- *          (1 MB), 2097152 (2 MB), 4194304 (4 MB), 8388608 (8 MB), and so on. The minimum allowable
- *          part size is 1 MB, and the maximum is 4 GB.</p>
- *
- *          <p>Every part you upload to this resource (see <a>UploadMultipartPart</a>),
- *          except the last one, must have the same size. The last one can be the same size or smaller.
- *          For example, suppose you want to upload a 16.2 MB file. If you initiate the multipart
- *          upload with a part size of 4 MB, you will upload four parts of 4 MB each and one part of
- *          0.2 MB. </p>
- *
- *          <note>
- *             <p>You don't need to know the size of the archive when you start a multipart upload
- *             because Amazon S3 Glacier does not require you to specify the overall archive
- *             size.</p>
- *          </note>
- *
- *          <p>After you complete the multipart upload, Amazon S3 Glacier (Glacier) removes the multipart upload
- *          resource referenced by the ID. Glacier also removes the multipart upload resource if
- *          you cancel the multipart upload or it may be removed if there is no activity for a period
- *          of 24 hours.</p>
- *
- *          <p>An AWS account has full permission to perform all operations (actions). However, AWS
- *          Identity and Access Management (IAM) users don't have any permissions by default. You must
- *          grant them explicit permission to perform specific actions. For more information, see
- *             <a href="https://docs.aws.amazon.com/amazonglacier/latest/dev/using-iam-with-amazon-glacier.html">Access Control Using
- *             AWS Identity and Access Management (IAM)</a>.</p>
- *          <p>For conceptual information and underlying REST API, see <a href="https://docs.aws.amazon.com/amazonglacier/latest/dev/uploading-archive-mpu.html">Uploading Large Archives in
- *             Parts (Multipart Upload)</a> and <a href="https://docs.aws.amazon.com/amazonglacier/latest/dev/api-multipart-initiate-upload.html">Initiate Multipart
- *             Upload</a> in the <i>Amazon Glacier Developer Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlacierClient, InitiateMultipartUploadCommand } from "@aws-sdk/client-glacier"; // ES Modules import
- * // const { GlacierClient, InitiateMultipartUploadCommand } = require("@aws-sdk/client-glacier"); // CommonJS import
- * const client = new GlacierClient(config);
- * const command = new InitiateMultipartUploadCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link InitiateMultipartUploadCommandInput} for command's `input` shape.
- * @see {@link InitiateMultipartUploadCommandOutput} for command's `response` shape.
- * @see {@link GlacierClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class InitiateMultipartUploadCommand extends $Command<
-  InitiateMultipartUploadCommandInput,
-  InitiateMultipartUploadCommandOutput,
-  GlacierClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: InitiateMultipartUploadCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: GlacierClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<InitiateMultipartUploadCommandInput, InitiateMultipartUploadCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "GlacierClient";
-    const commandName = "InitiateMultipartUploadCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: InitiateMultipartUploadInput.filterSensitiveLog,
-      outputFilterSensitiveLog: InitiateMultipartUploadOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: InitiateMultipartUploadCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1InitiateMultipartUploadCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<InitiateMultipartUploadCommandOutput> {
-    return deserializeAws_restJson1InitiateMultipartUploadCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/InitiateVaultLockCommand.ts

@@ -1,129 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { GlacierClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GlacierClient";
-import { InitiateVaultLockInput, InitiateVaultLockOutput } from "../models/models_0";
-import {
-  deserializeAws_restJson1InitiateVaultLockCommand,
-  serializeAws_restJson1InitiateVaultLockCommand,
-} from "../protocols/Aws_restJson1";
-
-export interface InitiateVaultLockCommandInput extends InitiateVaultLockInput {}
-export interface InitiateVaultLockCommandOutput extends InitiateVaultLockOutput, __MetadataBearer {}
-
-/**
- * <p>This operation initiates the vault locking process by doing the following:</p>
- *          <ul>
- *             <li>
- *                <p>Installing a vault lock policy on the specified vault.</p>
- *             </li>
- *             <li>
- *                <p>Setting the lock state of vault lock to <code>InProgress</code>.</p>
- *             </li>
- *             <li>
- *                <p>Returning a lock ID, which is used to complete the vault locking
- *                process.</p>
- *             </li>
- *          </ul>
- *
- *          <p>You can set one vault lock policy for each vault and this policy can be up to 20 KB
- *          in size. For more information about vault lock policies, see <a href="https://docs.aws.amazon.com/amazonglacier/latest/dev/vault-lock-policy.html">Amazon Glacier Access Control with
- *             Vault Lock Policies</a>. </p>
- *          <p>You must complete the vault locking process within 24 hours after the vault lock
- *          enters the <code>InProgress</code> state. After the 24 hour window ends, the lock ID
- *          expires, the vault automatically exits the <code>InProgress</code> state, and the vault
- *          lock policy is removed from the vault. You call <a>CompleteVaultLock</a> to
- *          complete the vault locking process by setting the state of the vault lock to
- *             <code>Locked</code>. </p>
- *          <p>After a vault lock is in the <code>Locked</code> state, you cannot initiate a new
- *          vault lock for the vault.</p>
- *
- *          <p>You can abort the vault locking process by calling <a>AbortVaultLock</a>.
- *          You can get the state of the vault lock by calling <a>GetVaultLock</a>. For more
- *          information about the vault locking process, <a href="https://docs.aws.amazon.com/amazonglacier/latest/dev/vault-lock.html">Amazon Glacier Vault
- *          Lock</a>.</p>
- *
- *          <p>If this operation is called when the vault lock is in the <code>InProgress</code>
- *          state, the operation returns an <code>AccessDeniedException</code> error. When the vault
- *          lock is in the <code>InProgress</code> state you must call <a>AbortVaultLock</a>
- *          before you can initiate a new vault lock policy. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlacierClient, InitiateVaultLockCommand } from "@aws-sdk/client-glacier"; // ES Modules import
- * // const { GlacierClient, InitiateVaultLockCommand } = require("@aws-sdk/client-glacier"); // CommonJS import
- * const client = new GlacierClient(config);
- * const command = new InitiateVaultLockCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link InitiateVaultLockCommandInput} for command's `input` shape.
- * @see {@link InitiateVaultLockCommandOutput} for command's `response` shape.
- * @see {@link GlacierClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class InitiateVaultLockCommand extends $Command<
-  InitiateVaultLockCommandInput,
-  InitiateVaultLockCommandOutput,
-  GlacierClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: InitiateVaultLockCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: GlacierClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<InitiateVaultLockCommandInput, InitiateVaultLockCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "GlacierClient";
-    const commandName = "InitiateVaultLockCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: InitiateVaultLockInput.filterSensitiveLog,
-      outputFilterSensitiveLog: InitiateVaultLockOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: InitiateVaultLockCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1InitiateVaultLockCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<InitiateVaultLockCommandOutput> {
-    return deserializeAws_restJson1InitiateVaultLockCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/ListJobsCommand.ts

@@ -1,130 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { GlacierClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GlacierClient";
-import { ListJobsInput, ListJobsOutput } from "../models/models_0";
-import {
-  deserializeAws_restJson1ListJobsCommand,
-  serializeAws_restJson1ListJobsCommand,
-} from "../protocols/Aws_restJson1";
-
-export interface ListJobsCommandInput extends ListJobsInput {}
-export interface ListJobsCommandOutput extends ListJobsOutput, __MetadataBearer {}
-
-/**
- * <p>This operation lists jobs for a vault, including jobs that are in-progress and jobs
- *          that have recently finished. The List Job operation returns a list of these jobs sorted by job initiation
- *          time.</p>
- *
- *          <note>
- *             <p>Amazon Glacier retains recently completed jobs for a period before deleting them;
- *             however, it eventually removes completed jobs. The output of completed jobs can be
- *             retrieved. Retaining completed jobs for a period of time after they have completed
- *             enables you to get a job output in the event you miss the job completion notification or
- *             your first attempt to download it fails. For example, suppose you start an archive
- *             retrieval job to download an archive. After the job completes, you start to download the
- *             archive but encounter a network error. In this scenario, you can retry and download the
- *             archive while the job exists.</p>
- *          </note>
- *
- *          <p>The List Jobs operation supports pagination. You should always check the response <code>Marker</code> field.
- *          If there are no more jobs to list, the <code>Marker</code> field is set to <code>null</code>. If there are more jobs to list,
- *          the <code>Marker</code> field is set to a non-null value, which you can use to continue the pagination of the list.
- *          To return a list of jobs that begins at a specific job,
- *          set the marker request parameter to the <code>Marker</code> value for that job that you obtained from a previous List Jobs request.</p>
- *
- *          <p>You can set a maximum limit for the number of jobs returned in the response by
- *          specifying the <code>limit</code> parameter in the request. The default limit is 50. The
- *          number of jobs returned might be fewer than the limit, but the number of returned jobs
- *          never exceeds the limit.</p>
- *
- *         <p>Additionally, you can filter the jobs list returned by specifying the optional
- *             <code>statuscode</code> parameter or <code>completed</code> parameter, or both. Using
- *          the <code>statuscode</code> parameter, you can specify to return only jobs that match
- *          either the <code>InProgress</code>, <code>Succeeded</code>, or <code>Failed</code> status.
- *          Using the <code>completed</code> parameter, you can specify to return only jobs that were
- *          completed (<code>true</code>) or jobs that were not completed
- *          (<code>false</code>).</p>
- *
- *          <p>For more information about using this operation,
- *          see the documentation for the underlying REST API <a href="https://docs.aws.amazon.com/amazonglacier/latest/dev/api-jobs-get.html">List Jobs</a>. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlacierClient, ListJobsCommand } from "@aws-sdk/client-glacier"; // ES Modules import
- * // const { GlacierClient, ListJobsCommand } = require("@aws-sdk/client-glacier"); // CommonJS import
- * const client = new GlacierClient(config);
- * const command = new ListJobsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListJobsCommandInput} for command's `input` shape.
- * @see {@link ListJobsCommandOutput} for command's `response` shape.
- * @see {@link GlacierClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class ListJobsCommand extends $Command<
-  ListJobsCommandInput,
-  ListJobsCommandOutput,
-  GlacierClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: ListJobsCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: GlacierClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<ListJobsCommandInput, ListJobsCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "GlacierClient";
-    const commandName = "ListJobsCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: ListJobsInput.filterSensitiveLog,
-      outputFilterSensitiveLog: ListJobsOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: ListJobsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1ListJobsCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ListJobsCommandOutput> {
-    return deserializeAws_restJson1ListJobsCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/ListMultipartUploadsCommand.ts

@@ -1,120 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { GlacierClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GlacierClient";
-import { ListMultipartUploadsInput, ListMultipartUploadsOutput } from "../models/models_0";
-import {
-  deserializeAws_restJson1ListMultipartUploadsCommand,
-  serializeAws_restJson1ListMultipartUploadsCommand,
-} from "../protocols/Aws_restJson1";
-
-export interface ListMultipartUploadsCommandInput extends ListMultipartUploadsInput {}
-export interface ListMultipartUploadsCommandOutput extends ListMultipartUploadsOutput, __MetadataBearer {}
-
-/**
- * <p>This operation lists in-progress multipart uploads for the specified vault. An
- *          in-progress multipart upload is a multipart upload that has been initiated by an <a>InitiateMultipartUpload</a> request, but has not yet been completed or aborted.
- *          The list returned in the List Multipart Upload response has no guaranteed order. </p>
- *
- *          <p>The List Multipart Uploads operation supports pagination. By default, this operation
- *          returns up to 50 multipart uploads in the response. You should always check the response
- *          for a <code>marker</code> at which to continue the list; if there are no more items the
- *             <code>marker</code> is <code>null</code>. To return a list of multipart uploads that
- *          begins at a specific upload, set the <code>marker</code> request parameter to the value you
- *          obtained from a previous List Multipart Upload request. You can also limit the number of
- *          uploads returned in the response by specifying the <code>limit</code> parameter in the
- *          request.</p>
- *
- *          <p>Note the difference between this operation and listing parts (<a>ListParts</a>). The List Multipart Uploads operation lists all multipart uploads
- *          for a vault and does not require a multipart upload ID. The List Parts operation requires a
- *          multipart upload ID since parts are associated with a single upload.</p>
- *
- *          <p>An AWS account has full permission to perform all operations (actions). However, AWS
- *          Identity and Access Management (IAM) users don't have any permissions by default. You must
- *          grant them explicit permission to perform specific actions. For more information, see
- *             <a href="https://docs.aws.amazon.com/amazonglacier/latest/dev/using-iam-with-amazon-glacier.html">Access Control Using
- *             AWS Identity and Access Management (IAM)</a>.</p>
- *
- *          <p>For conceptual information and the underlying REST API, see <a href="https://docs.aws.amazon.com/amazonglacier/latest/dev/working-with-archives.html">Working
- *             with Archives in Amazon S3 Glacier</a> and <a href="https://docs.aws.amazon.com/amazonglacier/latest/dev/api-multipart-list-uploads.html">List Multipart Uploads
- *          </a> in the <i>Amazon Glacier Developer Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlacierClient, ListMultipartUploadsCommand } from "@aws-sdk/client-glacier"; // ES Modules import
- * // const { GlacierClient, ListMultipartUploadsCommand } = require("@aws-sdk/client-glacier"); // CommonJS import
- * const client = new GlacierClient(config);
- * const command = new ListMultipartUploadsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListMultipartUploadsCommandInput} for command's `input` shape.
- * @see {@link ListMultipartUploadsCommandOutput} for command's `response` shape.
- * @see {@link GlacierClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class ListMultipartUploadsCommand extends $Command<
-  ListMultipartUploadsCommandInput,
-  ListMultipartUploadsCommandOutput,
-  GlacierClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: ListMultipartUploadsCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: GlacierClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<ListMultipartUploadsCommandInput, ListMultipartUploadsCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "GlacierClient";
-    const commandName = "ListMultipartUploadsCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: ListMultipartUploadsInput.filterSensitiveLog,
-      outputFilterSensitiveLog: ListMultipartUploadsOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: ListMultipartUploadsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1ListMultipartUploadsCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ListMultipartUploadsCommandOutput> {
-    return deserializeAws_restJson1ListMultipartUploadsCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/ListPartsCommand.ts

@@ -1,116 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { GlacierClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GlacierClient";
-import { ListPartsInput, ListPartsOutput } from "../models/models_0";
-import {
-  deserializeAws_restJson1ListPartsCommand,
-  serializeAws_restJson1ListPartsCommand,
-} from "../protocols/Aws_restJson1";
-
-export interface ListPartsCommandInput extends ListPartsInput {}
-export interface ListPartsCommandOutput extends ListPartsOutput, __MetadataBearer {}
-
-/**
- * <p>This operation lists the parts of an archive that have been uploaded in a specific
- *          multipart upload. You can make this request at any time during an in-progress multipart
- *          upload before you complete the upload (see <a>CompleteMultipartUpload</a>. List
- *          Parts returns an error for completed uploads. The list returned in the List Parts response
- *          is sorted by part range. </p>
- *
- *          <p>The List Parts operation supports pagination. By default, this operation returns up
- *          to 50 uploaded parts in the response. You should always check the response for a
- *             <code>marker</code> at which to continue the list; if there are no more items the
- *             <code>marker</code> is <code>null</code>. To return a list of parts that begins at a
- *          specific part, set the <code>marker</code> request parameter to the value you obtained from
- *          a previous List Parts request. You can also limit the number of parts returned in the
- *          response by specifying the <code>limit</code> parameter in the request. </p>
- *
- *          <p>An AWS account has full permission to perform all operations (actions). However, AWS
- *          Identity and Access Management (IAM) users don't have any permissions by default. You must
- *          grant them explicit permission to perform specific actions. For more information, see
- *             <a href="https://docs.aws.amazon.com/amazonglacier/latest/dev/using-iam-with-amazon-glacier.html">Access Control Using
- *             AWS Identity and Access Management (IAM)</a>.</p>
- *          <p>For conceptual information and the underlying REST API, see <a href="https://docs.aws.amazon.com/amazonglacier/latest/dev/working-with-archives.html">Working
- *             with Archives in Amazon S3 Glacier</a> and <a href="https://docs.aws.amazon.com/amazonglacier/latest/dev/api-multipart-list-parts.html">List Parts</a> in the
- *             <i>Amazon Glacier Developer Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlacierClient, ListPartsCommand } from "@aws-sdk/client-glacier"; // ES Modules import
- * // const { GlacierClient, ListPartsCommand } = require("@aws-sdk/client-glacier"); // CommonJS import
- * const client = new GlacierClient(config);
- * const command = new ListPartsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListPartsCommandInput} for command's `input` shape.
- * @see {@link ListPartsCommandOutput} for command's `response` shape.
- * @see {@link GlacierClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class ListPartsCommand extends $Command<
-  ListPartsCommandInput,
-  ListPartsCommandOutput,
-  GlacierClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: ListPartsCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: GlacierClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<ListPartsCommandInput, ListPartsCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "GlacierClient";
-    const commandName = "ListPartsCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: ListPartsInput.filterSensitiveLog,
-      outputFilterSensitiveLog: ListPartsOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: ListPartsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1ListPartsCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ListPartsCommandOutput> {
-    return deserializeAws_restJson1ListPartsCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}