This operation aborts a multipart upload. After a multipart upload is aborted, no\n * additional parts can be uploaded using that upload ID. The storage consumed by any\n * previously uploaded parts will be freed. However, if any part uploads are currently in\n * progress, those part uploads might or might not succeed. As a result, it might be necessary\n * to abort a given multipart upload multiple times in order to completely free all storage\n * consumed by all parts.
\n *To verify that all parts have been removed, so you don't get charged for the part\n * storage, you should call the ListParts operation and ensure that\n * the parts list is empty.
\n *For information about permissions required to use the multipart upload API, see Multipart Upload API and\n * Permissions.
\n *The following operations are related to AbortMultipartUpload:
\n * CreateMultipartUpload\n *
\n *\n * UploadPart\n *
\n *\n * CompleteMultipartUpload\n *
\n *\n * ListParts\n *
\n *\n * ListMultipartUploads\n *
\n *Completes a multipart upload by assembling previously uploaded parts.
\n *You first initiate the multipart upload and then upload all parts using the UploadPart\n * operation. After successfully uploading all relevant parts of an upload, you call this\n * operation to complete the upload. Upon receiving this request, Amazon S3 concatenates all\n * the parts in ascending order by part number to create a new object. In the Complete\n * Multipart Upload request, you must provide the parts list. You must ensure that the parts\n * list is complete. This operation concatenates the parts that you provide in the list. For\n * each part in the list, you must provide the part number and the ETag value,\n * returned after that part was uploaded.
Processing of a Complete Multipart Upload request could take several minutes to\n * complete. After Amazon S3 begins processing the request, it sends an HTTP response header that\n * specifies a 200 OK response. While processing is in progress, Amazon S3 periodically sends white\n * space characters to keep the connection from timing out. Because a request could fail after\n * the initial 200 OK response has been sent, it is important that you check the response body\n * to determine whether the request succeeded.
\n *Note that if CompleteMultipartUpload fails, applications should be prepared\n * to retry the failed requests. For more information, see Amazon S3 Error Best Practices.
For more information about multipart uploads, see Uploading Objects Using Multipart\n * Upload.
\n *For information about permissions required to use the multipart upload API, see Multipart Upload API and\n * Permissions.
\n *\n *\n *\n * CompleteMultipartUpload has the following special errors:
Error code: EntityTooSmall\n *
Description: Your proposed upload is smaller than the minimum allowed object\n * size. Each part must be at least 5 MB in size, except the last part.
\n *400 Bad Request
\n *Error code: InvalidPart\n *
Description: One or more of the specified parts could not be found. The part\n * might not have been uploaded, or the specified entity tag might not have\n * matched the part's entity tag.
\n *400 Bad Request
\n *Error code: InvalidPartOrder\n *
Description: The list of parts was not in ascending order. The parts list\n * must be specified in order by part number.
\n *400 Bad Request
\n *Error code: NoSuchUpload\n *
Description: The specified multipart upload does not exist. The upload ID\n * might be invalid, or the multipart upload might have been aborted or\n * completed.
\n *404 Not Found
\n *The following operations are related to CompleteMultipartUpload:
\n * CreateMultipartUpload\n *
\n *\n * UploadPart\n *
\n *\n * AbortMultipartUpload\n *
\n *\n * ListParts\n *
\n *\n * ListMultipartUploads\n *
\n *Creates a copy of an object that is already stored in Amazon S3.
\n *You can store individual objects of up to 5 TB in Amazon S3. You create a copy of your\n * object up to 5 GB in size in a single atomic operation using this API. However, to copy\n * an object greater than 5 GB, you must use the multipart upload Upload Part - Copy API.\n * For more information, see Copy Object Using the REST Multipart Upload API.
\n *All copy requests must be authenticated. Additionally, you must have\n * read access to the source object and write\n * access to the destination bucket. For more information, see REST Authentication. Both the Region\n * that you want to copy the object from and the Region that you want to copy the object to\n * must be enabled for your account.
\n *A copy request might return an error when Amazon S3 receives the copy request or while Amazon S3\n * is copying the files. If the error occurs before the copy operation starts, you receive a\n * standard Amazon S3 error. If the error occurs during the copy operation, the error response is\n * embedded in the 200 OK response. This means that a 200 OK\n * response can contain either a success or an error. Design your application to parse the\n * contents of the response and handle it appropriately.
If the copy is successful, you receive a response with information about the copied\n * object.
\n *If the request is an HTTP 1.1 request, the response is chunk encoded. If it were not,\n * it would not contain the content-length, and you would need to read the entire\n * body.
\n *The copy request charge is based on the storage class and Region that you specify for\n * the destination object. For pricing information, see Amazon S3 pricing.
\n *Amazon S3 transfer acceleration does not support cross-Region copies. If you request a\n * cross-Region copy using a transfer acceleration endpoint, you get a 400 Bad\n * Request error. For more information, see Transfer Acceleration.
\n * Metadata\n *
\n *When copying an object, you can preserve all metadata (default) or specify new metadata.\n * However, the ACL is not preserved and is set to private for the user making the request. To\n * override the default ACL setting, specify a new ACL when generating a copy request. For\n * more information, see Using ACLs.
\n *To specify whether you want the object metadata copied from the source object or\n * replaced with metadata provided in the request, you can optionally add the\n * x-amz-metadata-directive header. When you grant permissions, you can use\n * the s3:x-amz-metadata-directive condition key to enforce certain metadata\n * behavior when objects are uploaded. For more information, see Specifying Conditions in a\n * Policy in the Amazon S3 Developer Guide. For a complete list of\n * Amazon S3-specific condition keys, see Actions, Resources, and Condition Keys for\n * Amazon S3.
\n * \n * x-amz-copy-source-if Headers\n *
To only copy an object under certain conditions, such as whether the Etag\n * matches or whether the object was modified before or after a specified date, use the\n * following request parameters:
\n * x-amz-copy-source-if-match\n *
\n * x-amz-copy-source-if-none-match\n *
\n * x-amz-copy-source-if-unmodified-since\n *
\n * x-amz-copy-source-if-modified-since\n *
If both the x-amz-copy-source-if-match and\n * x-amz-copy-source-if-unmodified-since headers are present in the request\n * and evaluate as follows, Amazon S3 returns 200 OK and copies the data:
\n * x-amz-copy-source-if-match condition evaluates to true
\n * x-amz-copy-source-if-unmodified-since condition evaluates to\n * false
If both the x-amz-copy-source-if-none-match and\n * x-amz-copy-source-if-modified-since headers are present in the request and\n * evaluate as follows, Amazon S3 returns the 412 Precondition Failed response\n * code:
\n * x-amz-copy-source-if-none-match condition evaluates to false
\n * x-amz-copy-source-if-modified-since condition evaluates to\n * true
All headers with the x-amz- prefix, including\n * x-amz-copy-source, must be signed.
\n * Server-side encryption\n *
\n *When you perform a CopyObject operation, you can optionally use the appropriate encryption-related headers to encrypt the object using server-side encryption with AWS managed encryption keys (SSE-S3 or SSE-KMS) or a customer-provided encryption key. With server-side encryption, Amazon S3 encrypts your data as it writes it to disks in its data centers and decrypts the data when you access it. For more information about server-side encryption, see Using\n * Server-Side Encryption.
\n *If a target object uses SSE-KMS, you can enable an S3 Bucket Key for the object. For more\n * information, see Amazon S3 Bucket Keys in the Amazon Simple Storage Service Developer Guide.
\n *\n * Access Control List (ACL)-Specific Request\n * Headers\n *
\n *When copying an object, you can optionally use headers to grant ACL-based permissions.\n * By default, all objects are private. Only the owner has full access control. When adding a\n * new object, you can grant permissions to individual AWS accounts or to predefined groups\n * defined by Amazon S3. These permissions are then added to the ACL on the object. For more\n * information, see Access Control List (ACL) Overview and Managing ACLs Using the REST\n * API.
\n *\n *\n * Storage Class Options\n *
\n *You can use the CopyObject operation to change the storage class of an\n * object that is already stored in Amazon S3 using the StorageClass parameter. For\n * more information, see Storage\n * Classes in the Amazon S3 Service Developer Guide.
\n * Versioning\n *
\n *By default, x-amz-copy-source identifies the current version of an object\n * to copy. If the current version is a delete marker, Amazon S3 behaves as if the object was\n * deleted. To copy a different version, use the versionId subresource.
If you enable versioning on the target bucket, Amazon S3 generates a unique version ID for\n * the object being copied. This version ID is different from the version ID of the source\n * object. Amazon S3 returns the version ID of the copied object in the\n * x-amz-version-id response header in the response.
If you do not enable versioning or suspend it on the target bucket, the version ID that\n * Amazon S3 generates is always null.
\n *If the source object's storage class is GLACIER, you must restore a copy of this object\n * before you can use it as a source object for the copy operation. For more information, see\n * RestoreObject.
\n *The following operations are related to CopyObject:
For more information, see Copying\n * Objects.
\n */\nvar CopyObjectCommand = /** @class */ (function (_super) {\n __extends(CopyObjectCommand, _super);\n // Start section: command_properties\n // End section: command_properties\n function CopyObjectCommand(input) {\n var _this = \n // Start section: command_constructor\n _super.call(this) || this;\n _this.input = input;\n return _this;\n // End section: command_constructor\n }\n /**\n * @internal\n */\n CopyObjectCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {\n this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));\n this.middlewareStack.use(getThrow200ExceptionsPlugin(configuration));\n this.middlewareStack.use(getSsecPlugin(configuration));\n this.middlewareStack.use(getBucketEndpointPlugin(configuration));\n var stack = clientStack.concat(this.middlewareStack);\n var logger = configuration.logger;\n var clientName = \"S3Client\";\n var commandName = \"CopyObjectCommand\";\n var handlerExecutionContext = {\n logger: logger,\n clientName: clientName,\n commandName: commandName,\n inputFilterSensitiveLog: CopyObjectRequest.filterSensitiveLog,\n outputFilterSensitiveLog: CopyObjectOutput.filterSensitiveLog,\n };\n var requestHandler = configuration.requestHandler;\n return stack.resolve(function (request) {\n return requestHandler.handle(request.request, options || {});\n }, handlerExecutionContext);\n };\n CopyObjectCommand.prototype.serialize = function (input, context) {\n return serializeAws_restXmlCopyObjectCommand(input, context);\n };\n CopyObjectCommand.prototype.deserialize = function (output, context) {\n return deserializeAws_restXmlCopyObjectCommand(output, context);\n };\n return CopyObjectCommand;\n}($Command));\nexport { CopyObjectCommand };\n//# sourceMappingURL=CopyObjectCommand.js.map","import { __extends } from \"tslib\";\nimport { CreateMultipartUploadOutput, CreateMultipartUploadRequest } from \"../models/models_0\";\nimport { deserializeAws_restXmlCreateMultipartUploadCommand, serializeAws_restXmlCreateMultipartUploadCommand, } from \"../protocols/Aws_restXml\";\nimport { getBucketEndpointPlugin } from \"@aws-sdk/middleware-bucket-endpoint\";\nimport { getSerdePlugin } from \"@aws-sdk/middleware-serde\";\nimport { getSsecPlugin } from \"@aws-sdk/middleware-ssec\";\nimport { Command as $Command } from \"@aws-sdk/smithy-client\";\n/**\n *This operation initiates a multipart upload and returns an upload ID. This upload ID is\n * used to associate all of the parts in the specific multipart upload. You specify this\n * upload ID in each of your subsequent upload part requests (see UploadPart). You also include this\n * upload ID in the final request to either complete or abort the multipart upload\n * request.
\n *\n *For more information about multipart uploads, see Multipart Upload Overview.
\n *\n *If you have configured a lifecycle rule to abort incomplete multipart uploads, the\n * upload must complete within the number of days specified in the bucket lifecycle\n * configuration. Otherwise, the incomplete multipart upload becomes eligible for an abort\n * operation and Amazon S3 aborts the multipart upload. For more information, see Aborting\n * Incomplete Multipart Uploads Using a Bucket Lifecycle Policy.
\n *\n *For information about the permissions required to use the multipart upload API, see\n * Multipart Upload API and\n * Permissions.
\n *\n *For request signing, multipart upload is just a series of regular requests. You initiate\n * a multipart upload, send one or more requests to upload parts, and then complete the\n * multipart upload process. You sign each request individually. There is nothing special\n * about signing multipart upload requests. For more information about signing, see Authenticating\n * Requests (AWS Signature Version 4).
\n *\n *After you initiate a multipart upload and upload one or more parts, to stop being\n * charged for storing the uploaded parts, you must either complete or abort the multipart\n * upload. Amazon S3 frees up the space used to store the parts and stop charging you for\n * storing them only after you either complete or abort a multipart upload.
\n *You can optionally request server-side encryption. For server-side encryption, Amazon S3\n * encrypts your data as it writes it to disks in its data centers and decrypts it when you\n * access it. You can provide your own encryption key, or use AWS Key Management Service (AWS\n * KMS) customer master keys (CMKs) or Amazon S3-managed encryption keys. If you choose to provide\n * your own encryption key, the request headers you provide in UploadPart and UploadPartCopy requests must match the headers you used in the request to\n * initiate the upload by using CreateMultipartUpload.
To perform a multipart upload with encryption using an AWS KMS CMK, the requester must\n * have permission to the kms:Encrypt, kms:Decrypt,\n * kms:ReEncrypt*, kms:GenerateDataKey*, and\n * kms:DescribeKey actions on the key. These permissions are required because\n * Amazon S3 must decrypt and read data from the encrypted file parts before it completes the\n * multipart upload.
If your AWS Identity and Access Management (IAM) user or role is in the same AWS account\n * as the AWS KMS CMK, then you must have these permissions on the key policy. If your IAM\n * user or role belongs to a different account than the key, then you must have the\n * permissions on both the key policy and your IAM user or role.
\n *\n *\n *For more information, see Protecting\n * Data Using Server-Side Encryption.
\n *\n *When copying an object, you can optionally specify the accounts or groups that\n * should be granted specific permissions on the new object. There are two ways to\n * grant the permissions using the request headers:
\n *Specify a canned ACL with the x-amz-acl request header. For\n * more information, see Canned ACL.
Specify access permissions explicitly with the\n * x-amz-grant-read, x-amz-grant-read-acp,\n * x-amz-grant-write-acp, and\n * x-amz-grant-full-control headers. These parameters map to\n * the set of permissions that Amazon S3 supports in an ACL. For more information,\n * see Access Control List (ACL)\n * Overview.
You can use either a canned ACL or specify access permissions explicitly. You\n * cannot do both.
\n *You can optionally tell Amazon S3 to encrypt data at rest using server-side\n * encryption. Server-side encryption is for data encryption at rest. Amazon S3 encrypts\n * your data as it writes it to disks in its data centers and decrypts it when you\n * access it. The option you use depends on whether you want to use AWS managed\n * encryption keys or provide your own encryption key.
\n *Use encryption keys managed by Amazon S3 or customer master keys (CMKs) stored\n * in AWS Key Management Service (AWS KMS) – If you want AWS to manage the keys\n * used to encrypt data, specify the following headers in the request.
\n *x-amz-server-side-encryption
\n *x-amz-server-side-encryption-aws-kms-key-id
\n *x-amz-server-side-encryption-context
\n *If you specify x-amz-server-side-encryption:aws:kms, but\n * don't provide x-amz-server-side-encryption-aws-kms-key-id,\n * Amazon S3 uses the AWS managed CMK in AWS KMS to protect the data.
All GET and PUT requests for an object protected by AWS KMS fail if\n * you don't make them with SSL or by using SigV4.
\n *For more information about server-side encryption with CMKs stored in AWS\n * KMS (SSE-KMS), see Protecting Data Using Server-Side Encryption with CMKs stored in AWS\n * KMS.
\n *Use customer-provided encryption keys – If you want to manage your own\n * encryption keys, provide all the following headers in the request.
\n *x-amz-server-side-encryption-customer-algorithm
\n *x-amz-server-side-encryption-customer-key
\n *x-amz-server-side-encryption-customer-key-MD5
\n *For more information about server-side encryption with CMKs stored in AWS\n * KMS (SSE-KMS), see Protecting Data Using Server-Side Encryption with CMKs stored in AWS\n * KMS.
\n *You also can use the following access control–related headers with this\n * operation. By default, all objects are private. Only the owner has full access\n * control. When adding a new object, you can grant permissions to individual AWS\n * accounts or to predefined groups defined by Amazon S3. These permissions are then added\n * to the access control list (ACL) on the object. For more information, see Using ACLs. With this\n * operation, you can grant access permissions using one of the following two\n * methods:
\n *Specify a canned ACL (x-amz-acl) — Amazon S3 supports a set of\n * predefined ACLs, known as canned ACLs. Each canned ACL\n * has a predefined set of grantees and permissions. For more information, see\n * Canned\n * ACL.
Specify access permissions explicitly — To explicitly grant access\n * permissions to specific AWS accounts or groups, use the following headers.\n * Each header maps to specific permissions that Amazon S3 supports in an ACL. For\n * more information, see Access\n * Control List (ACL) Overview. In the header, you specify a list of\n * grantees who get the specific permission. To grant permissions explicitly,\n * use:
\n *x-amz-grant-read
\n *x-amz-grant-write
\n *x-amz-grant-read-acp
\n *x-amz-grant-write-acp
\n *x-amz-grant-full-control
\n *You specify each grantee as a type=value pair, where the type is one of\n * the following:
\n *\n * id – if the value specified is the canonical user ID\n * of an AWS account
\n * uri – if you are granting permissions to a predefined\n * group
\n * emailAddress – if the value specified is the email\n * address of an AWS account
Using email addresses to specify a grantee is only supported in the following AWS Regions:
\n *US East (N. Virginia)
\n *US West (N. California)
\n *US West (Oregon)
\n *Asia Pacific (Singapore)
\n *Asia Pacific (Sydney)
\n *Asia Pacific (Tokyo)
\n *Europe (Ireland)
\n *South America (São Paulo)
\n *For a list of all the Amazon S3 supported Regions and endpoints, see Regions and Endpoints in the AWS General Reference.
\n *For example, the following x-amz-grant-read header grants the AWS accounts identified by account IDs permissions to read object data and its metadata:
\n * x-amz-grant-read: id=\"11112222333\", id=\"444455556666\" \n *
The following operations are related to CreateMultipartUpload:
\n * UploadPart\n *
\n *\n * CompleteMultipartUpload\n *
\n *\n * AbortMultipartUpload\n *
\n *\n * ListParts\n *
\n *\n * ListMultipartUploads\n *
\n *Removes the null version (if there is one) of an object and inserts a delete marker,\n * which becomes the latest version of the object. If there isn't a null version, Amazon S3 does\n * not remove any objects.
\n *\n *To remove a specific version, you must be the bucket owner and you must use the version\n * Id subresource. Using this subresource permanently deletes the version. If the object\n * deleted is a delete marker, Amazon S3 sets the response header,\n * x-amz-delete-marker, to true.
If the object you want to delete is in a bucket where the bucket versioning\n * configuration is MFA Delete enabled, you must include the x-amz-mfa request\n * header in the DELETE versionId request. Requests that include\n * x-amz-mfa must use HTTPS.
For more information about MFA Delete, see Using MFA Delete. To see sample requests that use versioning, see Sample Request.
\n *\n *You can delete objects by explicitly calling the DELETE Object API or configure its\n * lifecycle (PutBucketLifecycle) to\n * enable Amazon S3 to remove them for you. If you want to block users or accounts from removing or\n * deleting objects from your bucket, you must deny them the s3:DeleteObject,\n * s3:DeleteObjectVersion, and s3:PutLifeCycleConfiguration\n * actions.
The following operation is related to DeleteObject:
\n * PutObject\n *
\n *Retrieves objects from Amazon S3. To use GET, you must have READ\n * access to the object. If you grant READ access to the anonymous user, you can\n * return the object without using an authorization header.
An Amazon S3 bucket has no directory hierarchy such as you would find in a typical computer\n * file system. You can, however, create a logical hierarchy by using object key names that\n * imply a folder structure. For example, instead of naming an object sample.jpg,\n * you can name it photos/2006/February/sample.jpg.
To get an object from such a logical hierarchy, specify the full key name for the object\n * in the GET operation. For a virtual hosted-style request example, if you have\n * the object photos/2006/February/sample.jpg, specify the resource as\n * /photos/2006/February/sample.jpg. For a path-style request example, if you\n * have the object photos/2006/February/sample.jpg in the bucket named\n * examplebucket, specify the resource as\n * /examplebucket/photos/2006/February/sample.jpg. For more information about\n * request types, see HTTP Host Header Bucket Specification.
To distribute large files to many people, you can save bandwidth costs by using\n * BitTorrent. For more information, see Amazon S3\n * Torrent. For more information about returning the ACL of an object, see GetObjectAcl.
\n *\n *If the object you are retrieving is stored in the S3 Glacier or\n * S3 Glacier Deep Archive storage class, or S3 Intelligent-Tiering Archive or\n * S3 Intelligent-Tiering Deep Archive tiers, before you can retrieve the object you must first restore a\n * copy using RestoreObject. Otherwise, this operation returns an\n * InvalidObjectStateError error. For information about restoring archived\n * objects, see Restoring Archived\n * Objects.
Encryption request headers, like x-amz-server-side-encryption, should not\n * be sent for GET requests if your object uses server-side encryption with CMKs stored in AWS\n * KMS (SSE-KMS) or server-side encryption with Amazon S3–managed encryption keys (SSE-S3). If your\n * object does use these types of keys, you’ll get an HTTP 400 BadRequest error.
If you encrypt an object by using server-side encryption with customer-provided\n * encryption keys (SSE-C) when you store the object in Amazon S3, then when you GET the object,\n * you must use the following headers:
\n *x-amz-server-side-encryption-customer-algorithm
\n *x-amz-server-side-encryption-customer-key
\n *x-amz-server-side-encryption-customer-key-MD5
\n *For more information about SSE-C, see Server-Side Encryption (Using\n * Customer-Provided Encryption Keys).
\n *\n *Assuming you have permission to read object tags (permission for the\n * s3:GetObjectVersionTagging action), the response also returns the\n * x-amz-tagging-count header that provides the count of number of tags\n * associated with the object. You can use GetObjectTagging to retrieve\n * the tag set associated with an object.
\n * Permissions\n *
\n *You need the s3:GetObject permission for this operation. For more\n * information, see Specifying Permissions\n * in a Policy. If the object you request does not exist, the error Amazon S3 returns\n * depends on whether you also have the s3:ListBucket permission.
If you have the s3:ListBucket permission on the bucket, Amazon S3 will\n * return an HTTP status code 404 (\"no such key\") error.
If you don’t have the s3:ListBucket permission, Amazon S3 will return an\n * HTTP status code 403 (\"access denied\") error.
\n * Versioning\n *
\n *By default, the GET operation returns the current version of an object. To return a\n * different version, use the versionId subresource.
If the current version of the object is a delete marker, Amazon S3 behaves as if the\n * object was deleted and includes x-amz-delete-marker: true in the\n * response.
For more information about versioning, see PutBucketVersioning.
\n *\n *\n * Overriding Response Header Values\n *
\n *There are times when you want to override certain response header values in a GET\n * response. For example, you might override the Content-Disposition response header value in\n * your GET request.
\n *\n *You can override values for a set of response headers using the following query\n * parameters. These response header values are sent only on a successful request, that is,\n * when status code 200 OK is returned. The set of headers you can override using these\n * parameters is a subset of the headers that Amazon S3 accepts when you create an object. The\n * response headers that you can override for the GET response are Content-Type,\n * Content-Language, Expires, Cache-Control,\n * Content-Disposition, and Content-Encoding. To override these\n * header values in the GET response, you use the following request parameters.
You must sign the request, either using an Authorization header or a presigned URL,\n * when using these parameters. They cannot be used with an unsigned (anonymous)\n * request.
\n *\n * response-content-type\n *
\n * response-content-language\n *
\n * response-expires\n *
\n * response-cache-control\n *
\n * response-content-disposition\n *
\n * response-content-encoding\n *
\n * Additional Considerations about Request Headers\n *
\n *\n *If both of the If-Match and If-Unmodified-Since headers are\n * present in the request as follows: If-Match condition evaluates to\n * true, and; If-Unmodified-Since condition evaluates to\n * false; then, S3 returns 200 OK and the data requested.
If both of the If-None-Match and If-Modified-Since headers are\n * present in the request as follows: If-None-Match condition evaluates to\n * false, and; If-Modified-Since condition evaluates to\n * true; then, S3 returns 304 Not Modified response code.
For more information about conditional requests, see RFC 7232.
\n *\n *The following operations are related to GetObject:
\n * ListBuckets\n *
\n *\n * GetObjectAcl\n *
\n *Returns some or all (up to 1,000) of the objects in a bucket. You can use the request\n * parameters as selection criteria to return a subset of the objects in a bucket. A 200\n * OK response can contain valid or invalid XML. Make sure to design your\n * application to parse the contents of the response and handle it appropriately.
To use this operation, you must have READ access to the bucket.
\n *\n *To use this operation in an AWS Identity and Access Management (IAM) policy, you must\n * have permissions to perform the s3:ListBucket action. The bucket owner has\n * this permission by default and can grant this permission to others. For more information\n * about permissions, see Permissions Related to Bucket Subresource Operations and Managing Access Permissions to Your Amazon S3\n * Resources.
This section describes the latest revision of the API. We recommend that you use this\n * revised API for application development. For backward compatibility, Amazon S3 continues to\n * support the prior version of this API, ListObjects.
\n *To get a list of your buckets, see ListBuckets.
\n *\n *The following operations are related to ListObjectsV2:
\n * GetObject\n *
\n *\n * PutObject\n *
\n *\n * CreateBucket\n *
\n *Lists the parts that have been uploaded for a specific multipart upload. This operation\n * must include the upload ID, which you obtain by sending the initiate multipart upload\n * request (see CreateMultipartUpload).\n * This request returns a maximum of 1,000 uploaded parts. The default number of parts\n * returned is 1,000 parts. You can restrict the number of parts returned by specifying the\n * max-parts request parameter. If your multipart upload consists of more than\n * 1,000 parts, the response returns an IsTruncated field with the value of true,\n * and a NextPartNumberMarker element. In subsequent ListParts\n * requests you can include the part-number-marker query string parameter and set its value to\n * the NextPartNumberMarker field value from the previous response.
For more information on multipart uploads, see Uploading Objects Using Multipart\n * Upload.
\n *\n *For information on permissions required to use the multipart upload API, see Multipart Upload API and\n * Permissions.
\n *\n *The following operations are related to ListParts:
\n * CreateMultipartUpload\n *
\n *\n * UploadPart\n *
\n *\n * CompleteMultipartUpload\n *
\n *\n * AbortMultipartUpload\n *
\n *\n * ListMultipartUploads\n *
\n *Adds an object to a bucket. You must have WRITE permissions on a bucket to add an object\n * to it.
\n *\n *\n *Amazon S3 never adds partial objects; if you receive a success response, Amazon S3 added the\n * entire object to the bucket.
\n *\n *Amazon S3 is a distributed system. If it receives multiple write requests for the same object\n * simultaneously, it overwrites all but the last object written. Amazon S3 does not provide object\n * locking; if you need this, make sure to build it into your application layer or use\n * versioning instead.
\n *\n *To ensure that data is not corrupted traversing the network, use the\n * Content-MD5 header. When you use this header, Amazon S3 checks the object\n * against the provided MD5 value and, if they do not match, returns an error. Additionally,\n * you can calculate the MD5 while putting an object to Amazon S3 and compare the returned ETag to\n * the calculated MD5 value.
The Content-MD5 header is required for any request to upload an object\n * with a retention period configured using Amazon S3 Object Lock. For more information about\n * Amazon S3 Object Lock, see Amazon S3 Object Lock Overview\n * in the Amazon Simple Storage Service Developer Guide.
\n * Server-side Encryption\n *
\n *You can optionally request server-side encryption. With server-side encryption, Amazon S3 encrypts your data as it writes it to disks in its data centers and decrypts the data\n * when you access it. You have the option to provide your own encryption key or use AWS\n * managed encryption keys (SSE-S3 or SSE-KMS). For more information, see Using Server-Side\n * Encryption.
\n *If you request server-side encryption using AWS Key Management Service (SSE-KMS), you can enable an S3 Bucket Key at the object-level. For more information, see Amazon S3 Bucket Keys in the Amazon Simple Storage Service Developer Guide.
\n *\n * Access Control List (ACL)-Specific Request\n * Headers\n *
\n *You can use headers to grant ACL- based permissions. By default, all objects are\n * private. Only the owner has full access control. When adding a new object, you can grant\n * permissions to individual AWS accounts or to predefined groups defined by Amazon S3. These\n * permissions are then added to the ACL on the object. For more information, see Access Control List\n * (ACL) Overview and Managing ACLs Using the REST\n * API.
\n *\n *\n * Storage Class Options\n *
\n *By default, Amazon S3 uses the STANDARD Storage Class to store newly created objects. The\n * STANDARD storage class provides high durability and high availability. Depending on\n * performance needs, you can specify a different Storage Class. Amazon S3 on Outposts only uses\n * the OUTPOSTS Storage Class. For more information, see Storage Classes in the Amazon S3\n * Service Developer Guide.
\n *\n *\n *\n * Versioning\n *
\n *If you enable versioning for a bucket, Amazon S3 automatically generates a unique version ID\n * for the object being stored. Amazon S3 returns this ID in the response. When you enable\n * versioning for a bucket, if Amazon S3 receives multiple write requests for the same object\n * simultaneously, it stores all of the objects.
\n *For more information about versioning, see Adding Objects to\n * Versioning Enabled Buckets. For information about returning the versioning state\n * of a bucket, see GetBucketVersioning.
\n *\n *\n *\n * Related Resources\n *
\n *\n * CopyObject\n *
\n *\n * DeleteObject\n *
\n *Uploads a part in a multipart upload.
\n *In this operation, you provide part data in your request. However, you have an option\n * to specify your existing Amazon S3 object as a data source for the part you are uploading. To\n * upload a part from an existing object, you use the UploadPartCopy operation.\n *
\n *You must initiate a multipart upload (see CreateMultipartUpload)\n * before you can upload any part. In response to your initiate request, Amazon S3 returns an\n * upload ID, a unique identifier, that you must include in your upload part request.
\n *Part numbers can be any number from 1 to 10,000, inclusive. A part number uniquely\n * identifies a part and also defines its position within the object being created. If you\n * upload a new part using the same part number that was used with a previous part, the\n * previously uploaded part is overwritten. Each part must be at least 5 MB in size, except\n * the last part. There is no size limit on the last part of your multipart upload.
\n *To ensure that data is not corrupted when traversing the network, specify the\n * Content-MD5 header in the upload part request. Amazon S3 checks the part data\n * against the provided MD5 value. If they do not match, Amazon S3 returns an error.
If the upload request is signed with Signature Version 4, then AWS S3 uses the\n * x-amz-content-sha256 header as a checksum instead of\n * Content-MD5. For more information see Authenticating Requests: Using the Authorization Header (AWS Signature Version\n * 4).
\n * Note: After you initiate multipart upload and upload\n * one or more parts, you must either complete or abort multipart upload in order to stop\n * getting charged for storage of the uploaded parts. Only after you either complete or abort\n * multipart upload, Amazon S3 frees up the parts storage and stops charging you for the parts\n * storage.
\n *\n *For more information on multipart uploads, go to Multipart Upload Overview in the\n * Amazon Simple Storage Service Developer Guide .
\n *For information on the permissions required to use the multipart upload API, go to\n * Multipart Upload API and\n * Permissions in the Amazon Simple Storage Service Developer Guide.
\n *\n *You can optionally request server-side encryption where Amazon S3 encrypts your data as it\n * writes it to disks in its data centers and decrypts it for you when you access it. You have\n * the option of providing your own encryption key, or you can use the AWS managed encryption\n * keys. If you choose to provide your own encryption key, the request headers you provide in\n * the request must match the headers you used in the request to initiate the upload by using\n * CreateMultipartUpload. For more information, go to Using Server-Side Encryption in\n * the Amazon Simple Storage Service Developer Guide.
\n *\n *Server-side encryption is supported by the S3 Multipart Upload actions. Unless you are\n * using a customer-provided encryption key, you don't need to specify the encryption\n * parameters in each UploadPart request. Instead, you only need to specify the server-side\n * encryption parameters in the initial Initiate Multipart request. For more information, see\n * CreateMultipartUpload.
\n *\n *If you requested server-side encryption using a customer-provided encryption key in your\n * initiate multipart upload request, you must provide identical encryption information in\n * each part upload using the following headers.
\n *\n *\n *x-amz-server-side-encryption-customer-algorithm
\n *x-amz-server-side-encryption-customer-key
\n *x-amz-server-side-encryption-customer-key-MD5
\n *\n * Special Errors\n *
\n *\n * Code: NoSuchUpload\n *
\n *\n * Cause: The specified multipart upload does not exist. The upload\n * ID might be invalid, or the multipart upload might have been aborted or\n * completed.\n *
\n *\n * HTTP Status Code: 404 Not Found \n *
\n *\n * SOAP Fault Code Prefix: Client\n *
\n *\n * Related Resources\n *
\n *\n * CreateMultipartUpload\n *
\n *\n * CompleteMultipartUpload\n *
\n *\n * AbortMultipartUpload\n *
\n *\n * ListParts\n *
\n *\n * ListMultipartUploads\n *
\n *