@nocobase/plugin-file-manager 1.2.13-alpha → 1.3.0-alpha.20240710084543

package/dist/node_modules/@aws-sdk/client-s3/dist-types/commands/CreateBucketCommand.d.ts

@@ -1,260 +0,0 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
-import { Command as $Command } from "@smithy/smithy-client";
-import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
-import { CreateBucketOutput, CreateBucketRequest } from "../models/models_0";
-import { S3ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../S3Client";
-/**
- * @public
- */
-export { __MetadataBearer, $Command };
-/**
- * @public
- *
- * The input for {@link CreateBucketCommand}.
- */
-export interface CreateBucketCommandInput extends CreateBucketRequest {
-}
-/**
- * @public
- *
- * The output of {@link CreateBucketCommand}.
- */
-export interface CreateBucketCommandOutput extends CreateBucketOutput, __MetadataBearer {
-}
-/**
- * @public
- * <note>
- *             <p>This action creates an Amazon S3 bucket. To create an Amazon S3 on Outposts bucket, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateBucket.html">
- *                   <code>CreateBucket</code>
- *                </a>.</p>
- *          </note>
- *          <p>Creates a new S3 bucket. To create a bucket, you must set up Amazon S3 and have a
- *          valid Amazon Web Services Access Key ID to authenticate requests. Anonymous requests are never allowed to
- *          create buckets. By creating the bucket, you become the bucket owner.</p>
- *          <p>There are two types of buckets: general purpose buckets and directory buckets. For more
- *          information about these bucket types, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-buckets-s3.html">Creating, configuring, and
- *             working with Amazon S3 buckets</a> in the <i>Amazon S3 User Guide</i>.</p>
- *          <note>
- *             <ul>
- *                <li>
- *                   <p>
- *                      <b>General purpose buckets</b> - If you send your <code>CreateBucket</code> request to the <code>s3.amazonaws.com</code> global endpoint,
- *                   the request goes to the <code>us-east-1</code> Region. So the signature
- *                   calculations in Signature Version 4 must use <code>us-east-1</code> as the Region, even
- *                   if the location constraint in the request specifies another Region where the bucket is
- *                   to be created. If you create a bucket in a Region other than US East (N. Virginia), your
- *                   application must be able to handle 307 redirect. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/VirtualHosting.html">Virtual hosting of
- *                      buckets</a> in the <i>Amazon S3 User Guide</i>.</p>
- *                </li>
- *                <li>
- *                   <p>
- *                      <b>Directory buckets </b> - For directory buckets, you must make requests for this API operation to the Regional endpoint. These endpoints support path-style requests in the format <code>https://s3express-control.<i>region_code</i>.amazonaws.com/<i>bucket-name</i>
- *                      </code>. Virtual-hosted-style requests aren't supported.
- * For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-Regions-and-Zones.html">Regional and Zonal endpoints</a> in the
- *     <i>Amazon S3 User Guide</i>.</p>
- *                </li>
- *             </ul>
- *          </note>
- *          <dl>
- *             <dt>Permissions</dt>
- *             <dd>
- *                <ul>
- *                   <li>
- *                      <p>
- *                         <b>General purpose bucket permissions</b> - In addition to the <code>s3:CreateBucket</code> permission, the following permissions are
- *                      required in a policy when your <code>CreateBucket</code> request includes specific
- *                      headers: </p>
- *                      <ul>
- *                         <li>
- *                            <p>
- *                               <b>Access control lists (ACLs)</b> - In your <code>CreateBucket</code> request, if you specify an access control list (ACL)
- *                               and set it to <code>public-read</code>, <code>public-read-write</code>,
- *                               <code>authenticated-read</code>, or if you explicitly specify any other custom ACLs, both <code>s3:CreateBucket</code> and
- *                               <code>s3:PutBucketAcl</code> permissions are required. In your <code>CreateBucket</code> request, if you set the ACL to <code>private</code>,
- *                               or if you don't specify any ACLs, only the <code>s3:CreateBucket</code> permission is required.
- *                            </p>
- *                         </li>
- *                         <li>
- *                            <p>
- *                               <b>Object Lock</b> - In your
- *                               <code>CreateBucket</code> request, if you set
- *                               <code>x-amz-bucket-object-lock-enabled</code> to true, the
- *                               <code>s3:PutBucketObjectLockConfiguration</code> and
- *                               <code>s3:PutBucketVersioning</code> permissions are required.</p>
- *                         </li>
- *                         <li>
- *                            <p>
- *                               <b>S3 Object Ownership</b> - If your
- *                               <code>CreateBucket</code> request includes the
- *                               <code>x-amz-object-ownership</code> header, then the
- *                               <code>s3:PutBucketOwnershipControls</code> permission is required.</p>
- *                            <important>
- *                               <p>If your <code>CreateBucket</code> request sets <code>BucketOwnerEnforced</code> for
- *                                  Amazon S3 Object Ownership and specifies a bucket ACL that provides access to an external
- *                                  Amazon Web Services account, your request fails with a <code>400</code> error and returns the
- *                                  <code>InvalidBucketAcLWithObjectOwnership</code> error code. For more information,
- *                                  see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-ownership-existing-bucket.html">Setting Object
- *                                     Ownership on an existing bucket </a> in the <i>Amazon S3 User Guide</i>.
- *                               </p>
- *                            </important>
- *                         </li>
- *                         <li>
- *                            <p>
- *                               <b>S3 Block Public Access</b> - If your
- *                               specific use case requires granting public access to your S3 resources, you
- *                               can disable Block Public Access. Specifically, you can create a new bucket with Block
- *                               Public Access enabled, then separately call the <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeletePublicAccessBlock.html">
- *                                  <code>DeletePublicAccessBlock</code>
- *                               </a> API. To use this operation, you must have the
- *                               <code>s3:PutBucketPublicAccessBlock</code> permission. For more information about S3 Block Public
- *                               Access, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-control-block-public-access.html">Blocking
- *                                  public access to your Amazon S3 storage </a> in the
- *                               <i>Amazon S3 User Guide</i>. </p>
- *                         </li>
- *                      </ul>
- *                   </li>
- *                   <li>
- *                      <p>
- *                         <b>Directory bucket permissions</b> - You must have the <code>s3express:CreateBucket</code> permission in an IAM identity-based policy instead of a bucket policy. Cross-account access to this API operation isn't supported. This operation can only be performed by the Amazon Web Services account that owns the resource. For more information about directory bucket policies and permissions, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-security-iam.html">Amazon Web Services Identity and Access Management (IAM) for S3 Express One Zone</a> in the <i>Amazon S3 User Guide</i>.</p>
- *                      <important>
- *                         <p>The permissions for ACLs, Object Lock, S3 Object Ownership, and S3 Block Public Access are not supported for directory buckets.
- *                         For directory buckets, all Block Public Access settings are enabled at the bucket level and S3
- *                         Object Ownership is set to Bucket owner enforced (ACLs disabled). These settings can't be modified.
- *                      </p>
- *                         <p>For more information about permissions for creating and working with
- *                            directory buckets, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-overview.html">Directory buckets</a> in the <i>Amazon S3 User Guide</i>.
- *                            For more information about supported S3 features for directory buckets, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-one-zone.html#s3-express-features">Features of S3 Express One Zone</a> in the <i>Amazon S3 User Guide</i>.</p>
- *                      </important>
- *                   </li>
- *                </ul>
- *             </dd>
- *             <dt>HTTP Host header syntax</dt>
- *             <dd>
- *                <p>
- *                   <b>Directory buckets </b> - The HTTP Host header syntax is <code>s3express-control.<i>region</i>.amazonaws.com</code>.</p>
- *             </dd>
- *          </dl>
- *          <p>The following operations are related to <code>CreateBucket</code>:</p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html">PutObject</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteBucket.html">DeleteBucket</a>
- *                </p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { S3Client, CreateBucketCommand } from "@aws-sdk/client-s3"; // ES Modules import
- * // const { S3Client, CreateBucketCommand } = require("@aws-sdk/client-s3"); // CommonJS import
- * const client = new S3Client(config);
- * const input = { // CreateBucketRequest
- *   ACL: "private" || "public-read" || "public-read-write" || "authenticated-read",
- *   Bucket: "STRING_VALUE", // required
- *   CreateBucketConfiguration: { // CreateBucketConfiguration
- *     LocationConstraint: "af-south-1" || "ap-east-1" || "ap-northeast-1" || "ap-northeast-2" || "ap-northeast-3" || "ap-south-1" || "ap-south-2" || "ap-southeast-1" || "ap-southeast-2" || "ap-southeast-3" || "ca-central-1" || "cn-north-1" || "cn-northwest-1" || "EU" || "eu-central-1" || "eu-north-1" || "eu-south-1" || "eu-south-2" || "eu-west-1" || "eu-west-2" || "eu-west-3" || "me-south-1" || "sa-east-1" || "us-east-2" || "us-gov-east-1" || "us-gov-west-1" || "us-west-1" || "us-west-2",
- *     Location: { // LocationInfo
- *       Type: "AvailabilityZone",
- *       Name: "STRING_VALUE",
- *     },
- *     Bucket: { // BucketInfo
- *       DataRedundancy: "SingleAvailabilityZone",
- *       Type: "Directory",
- *     },
- *   },
- *   GrantFullControl: "STRING_VALUE",
- *   GrantRead: "STRING_VALUE",
- *   GrantReadACP: "STRING_VALUE",
- *   GrantWrite: "STRING_VALUE",
- *   GrantWriteACP: "STRING_VALUE",
- *   ObjectLockEnabledForBucket: true || false,
- *   ObjectOwnership: "BucketOwnerPreferred" || "ObjectWriter" || "BucketOwnerEnforced",
- * };
- * const command = new CreateBucketCommand(input);
- * const response = await client.send(command);
- * // { // CreateBucketOutput
- * //   Location: "STRING_VALUE",
- * // };
- *
- * ```
- *
- * @param CreateBucketCommandInput - {@link CreateBucketCommandInput}
- * @returns {@link CreateBucketCommandOutput}
- * @see {@link CreateBucketCommandInput} for command's `input` shape.
- * @see {@link CreateBucketCommandOutput} for command's `response` shape.
- * @see {@link S3ClientResolvedConfig | config} for S3Client's `config` shape.
- *
- * @throws {@link BucketAlreadyExists} (client fault)
- *  <p>The requested bucket name is not available. The bucket namespace is shared by all users
- *          of the system. Select a different name and try again.</p>
- *
- * @throws {@link BucketAlreadyOwnedByYou} (client fault)
- *  <p>The bucket you tried to create already exists, and you own it. Amazon S3 returns this error
- *          in all Amazon Web Services Regions except in the North Virginia Region. For legacy compatibility, if you
- *          re-create an existing bucket that you already own in the North Virginia Region, Amazon S3
- *          returns 200 OK and resets the bucket access control lists (ACLs).</p>
- *
- * @throws {@link S3ServiceException}
- * <p>Base exception class for all service exceptions from S3 service.</p>
- *
- * @example To create a bucket in a specific region
- * ```javascript
- * // The following example creates a bucket. The request specifies an AWS region where to create the bucket.
- * const input = {
- *   "Bucket": "examplebucket",
- *   "CreateBucketConfiguration": {
- *     "LocationConstraint": "eu-west-1"
- *   }
- * };
- * const command = new CreateBucketCommand(input);
- * const response = await client.send(command);
- * /* response ==
- * {
- *   "Location": "http://examplebucket.<Region>.s3.amazonaws.com/"
- * }
- * *\/
- * // example id: to-create-a-bucket-in-a-specific-region-1483399072992
- * ```
- *
- * @example To create a bucket
- * ```javascript
- * // The following example creates a bucket.
- * const input = {
- *   "Bucket": "examplebucket"
- * };
- * const command = new CreateBucketCommand(input);
- * const response = await client.send(command);
- * /* response ==
- * {
- *   "Location": "/examplebucket"
- * }
- * *\/
- * // example id: to-create-a-bucket--1472851826060
- * ```
- *
- */
-export declare class CreateBucketCommand extends $Command<CreateBucketCommandInput, CreateBucketCommandOutput, S3ClientResolvedConfig> {
-    readonly input: CreateBucketCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: CreateBucketCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: S3ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateBucketCommandInput, CreateBucketCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
-}

package/dist/node_modules/@aws-sdk/client-s3/dist-types/commands/CreateMultipartUploadCommand.d.ts

@@ -1,351 +0,0 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
-import { Command as $Command } from "@smithy/smithy-client";
-import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
-import { CreateMultipartUploadOutput, CreateMultipartUploadRequest } from "../models/models_0";
-import { S3ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../S3Client";
-/**
- * @public
- */
-export { __MetadataBearer, $Command };
-/**
- * @public
- *
- * The input for {@link CreateMultipartUploadCommand}.
- */
-export interface CreateMultipartUploadCommandInput extends CreateMultipartUploadRequest {
-}
-/**
- * @public
- *
- * The output of {@link CreateMultipartUploadCommand}.
- */
-export interface CreateMultipartUploadCommandOutput extends CreateMultipartUploadOutput, __MetadataBearer {
-}
-/**
- * @public
- * <p>This action initiates a multipart upload and returns an upload ID. This upload ID is
- *          used to associate all of the parts in the specific multipart upload. You specify this
- *          upload ID in each of your subsequent upload part requests (see <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html">UploadPart</a>). You also include this
- *          upload ID in the final request to either complete or abort the multipart upload
- *          request. For more information about multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/mpuoverview.html">Multipart Upload Overview</a> in the <i>Amazon S3 User Guide</i>.</p>
- *          <note>
- *             <p>After you initiate a multipart upload and upload one or more parts, to stop being
- *             charged for storing the uploaded parts, you must either complete or abort the multipart
- *             upload. Amazon S3 frees up the space used to store the parts and stops charging you for
- *             storing them only after you either complete or abort a multipart upload. </p>
- *          </note>
- *          <p>If you have configured a lifecycle rule to abort incomplete multipart uploads, the created multipart
- *          upload must be completed within the number of days specified in the bucket lifecycle
- *          configuration. Otherwise, the incomplete multipart upload becomes eligible for an abort
- *          action and Amazon S3 aborts the multipart upload. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/mpuoverview.html#mpu-abort-incomplete-mpu-lifecycle-config">Aborting Incomplete Multipart Uploads Using a Bucket Lifecycle
- *             Configuration</a>.</p>
- *          <note>
- *             <ul>
- *                <li>
- *                   <p>
- *                      <b>Directory buckets </b> - S3 Lifecycle is not supported by directory buckets.</p>
- *                </li>
- *                <li>
- *                   <p>
- *                      <b>Directory buckets </b> - For directory buckets, you must make requests for this API operation to the Zonal endpoint. These endpoints support virtual-hosted-style requests in the format <code>https://<i>bucket_name</i>.s3express-<i>az_id</i>.<i>region</i>.amazonaws.com/<i>key-name</i>
- *                      </code>. Path-style requests are not supported. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-Regions-and-Zones.html">Regional and Zonal endpoints</a> in the
- *     <i>Amazon S3 User Guide</i>.</p>
- *                </li>
- *             </ul>
- *          </note>
- *          <dl>
- *             <dt>Request signing</dt>
- *             <dd>
- *                <p>For request signing, multipart upload is just a series of regular requests. You initiate
- *                a multipart upload, send one or more requests to upload parts, and then complete the
- *                multipart upload process. You sign each request individually. There is nothing special
- *                about signing multipart upload requests. For more information about signing, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-authenticating-requests.html">Authenticating Requests (Amazon Web Services Signature Version 4)</a> in the <i>Amazon S3 User Guide</i>.</p>
- *             </dd>
- *             <dt>Permissions</dt>
- *             <dd>
- *                <ul>
- *                   <li>
- *                      <p>
- *                         <b>General purpose bucket permissions</b> - For information about the permissions required to use the multipart upload API, see
- *                         <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/mpuAndPermissions.html">Multipart
- *                            upload and permissions</a> in the <i>Amazon S3 User Guide</i>. </p>
- *                      <p>To perform a multipart upload with encryption by using an Amazon Web Services KMS key, the requester
- *                         must have permission to the <code>kms:Decrypt</code> and <code>kms:GenerateDataKey*</code>
- *                         actions on the key. These permissions are required because Amazon S3 must decrypt and read data
- *                         from the encrypted file parts before it completes the multipart upload. For more
- *                         information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html#mpuAndPermissions">Multipart upload API
- *                            and permissions</a> and <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html">Protecting data using
- *                               server-side encryption with Amazon Web Services KMS</a> in the
- *                         <i>Amazon S3 User Guide</i>.</p>
- *                   </li>
- *                   <li>
- *                      <p>
- *                         <b>Directory bucket permissions</b> - To grant access to this API operation on a directory bucket, we recommend that you use the <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateSession.html">
- *                            <code>CreateSession</code>
- *                         </a> API operation for session-based authorization. Specifically, you grant the <code>s3express:CreateSession</code> permission to the directory bucket in a bucket policy or an IAM identity-based policy. Then, you make the <code>CreateSession</code> API call on the bucket to obtain a session token. With the session token in your request header, you can make API requests to this operation. After the session token expires, you make another <code>CreateSession</code> API call to generate a new session token for use.
- * Amazon Web Services CLI or SDKs create session and refresh the session token automatically to avoid service interruptions when a session expires. For more information about authorization, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateSession.html">
- *                            <code>CreateSession</code>
- *                         </a>.</p>
- *                   </li>
- *                </ul>
- *             </dd>
- *             <dt>Encryption</dt>
- *             <dd>
- *                <ul>
- *                   <li>
- *                      <p>
- *                         <b>General purpose buckets</b> - Server-side encryption is for data encryption at rest. Amazon S3 encrypts your data as it
- *                         writes it to disks in its data centers and decrypts it when you access it. Amazon S3
- *                         automatically encrypts all new objects that are uploaded to an S3 bucket. When doing a
- *                         multipart upload, if you don't specify encryption information in your request, the
- *                         encryption setting of the uploaded parts is set to the default encryption configuration of
- *                         the destination bucket. By default, all buckets have a base level of encryption
- *                         configuration that uses server-side encryption with Amazon S3 managed keys (SSE-S3). If the
- *                         destination bucket has a default encryption configuration that uses server-side encryption
- *                         with an Key Management Service (KMS) key (SSE-KMS), or a customer-provided encryption key (SSE-C),
- *                         Amazon S3 uses the corresponding KMS key, or a customer-provided key to encrypt the uploaded
- *                         parts. When you perform a CreateMultipartUpload operation, if you want to use a different
- *                         type of encryption setting for the uploaded parts, you can request that Amazon S3 encrypts the
- *                         object with a different encryption key (such as an Amazon S3 managed key, a KMS key, or a customer-provided key). When the encryption
- *                         setting in your request is different from the default encryption configuration of the
- *                         destination bucket, the encryption setting in your request takes precedence. If you choose
- *                         to provide your own encryption key, the request headers you provide in <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html">UploadPart</a>
- *                         and <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html">UploadPartCopy</a> requests must match the headers you used in the <code>CreateMultipartUpload</code> request.</p>
- *                      <ul>
- *                         <li>
- *                            <p>Use KMS keys (SSE-KMS) that include the Amazon Web Services managed key
- *                               (<code>aws/s3</code>) and KMS customer managed keys stored in Key Management Service (KMS) –
- *                               If you want Amazon Web Services to manage the keys used to encrypt data, specify the
- *                               following headers in the request.</p>
- *                            <ul>
- *                               <li>
- *                                  <p>
- *                                     <code>x-amz-server-side-encryption</code>
- *                                  </p>
- *                               </li>
- *                               <li>
- *                                  <p>
- *                                     <code>x-amz-server-side-encryption-aws-kms-key-id</code>
- *                                  </p>
- *                               </li>
- *                               <li>
- *                                  <p>
- *                                     <code>x-amz-server-side-encryption-context</code>
- *                                  </p>
- *                               </li>
- *                            </ul>
- *                            <note>
- *                               <ul>
- *                                  <li>
- *                                     <p>If you specify <code>x-amz-server-side-encryption:aws:kms</code>, but
- *                                     don't provide <code>x-amz-server-side-encryption-aws-kms-key-id</code>,
- *                                     Amazon S3 uses the Amazon Web Services managed key (<code>aws/s3</code> key) in KMS to
- *                                     protect the data.</p>
- *                                  </li>
- *                                  <li>
- *                                     <p>To perform a multipart upload with encryption by using an Amazon Web Services KMS key, the requester
- *                                     must have permission to the <code>kms:Decrypt</code> and <code>kms:GenerateDataKey*</code>
- *                                     actions on the key. These permissions are required because Amazon S3 must decrypt and read data
- *                                     from the encrypted file parts before it completes the multipart upload. For more
- *                                     information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html#mpuAndPermissions">Multipart upload API
- *                                        and permissions</a> and <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html">Protecting data using
- *                                           server-side encryption with Amazon Web Services KMS</a> in the
- *                                     <i>Amazon S3 User Guide</i>.</p>
- *                                  </li>
- *                                  <li>
- *                                     <p>If your Identity and Access Management (IAM) user or role is in the same Amazon Web Services account as the KMS key,
- *                                     then you must have these permissions on the key policy. If your IAM user or role is in a different account from the key, then you must have the permissions on both the key
- *                                     policy and your IAM user or role.</p>
- *                                  </li>
- *                                  <li>
- *                                     <p>All <code>GET</code> and <code>PUT</code> requests for an object
- *                                        protected by KMS fail if you don't make them by using Secure Sockets
- *                                        Layer (SSL), Transport Layer Security (TLS), or Signature Version
- *                                        4. For information about configuring any of the officially supported Amazon Web Services
- *                                        SDKs and Amazon Web Services CLI, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingAWSSDK.html#specify-signature-version">Specifying the Signature Version in Request Authentication</a>
- *                                        in the <i>Amazon S3 User Guide</i>.</p>
- *                                  </li>
- *                               </ul>
- *                            </note>
- *                            <p>For more information about server-side encryption with KMS keys
- *                               (SSE-KMS), see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html">Protecting Data
- *                                  Using Server-Side Encryption with KMS keys</a> in the <i>Amazon S3 User Guide</i>.</p>
- *                         </li>
- *                         <li>
- *                            <p>Use customer-provided encryption keys (SSE-C) – If you want to manage
- *                               your own encryption keys, provide all the following headers in the
- *                               request.</p>
- *                            <ul>
- *                               <li>
- *                                  <p>
- *                                     <code>x-amz-server-side-encryption-customer-algorithm</code>
- *                                  </p>
- *                               </li>
- *                               <li>
- *                                  <p>
- *                                     <code>x-amz-server-side-encryption-customer-key</code>
- *                                  </p>
- *                               </li>
- *                               <li>
- *                                  <p>
- *                                     <code>x-amz-server-side-encryption-customer-key-MD5</code>
- *                                  </p>
- *                               </li>
- *                            </ul>
- *                            <p>For more information about server-side encryption with customer-provided
- *                               encryption keys (SSE-C), see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/ServerSideEncryptionCustomerKeys.html">
- *                                  Protecting data using server-side encryption with customer-provided
- *                                  encryption keys (SSE-C)</a> in the <i>Amazon S3 User Guide</i>.</p>
- *                         </li>
- *                      </ul>
- *                   </li>
- *                   <li>
- *                      <p>
- *                         <b>Directory buckets</b> -For directory buckets, only server-side encryption with Amazon S3 managed keys (SSE-S3) (<code>AES256</code>) is supported.</p>
- *                   </li>
- *                </ul>
- *             </dd>
- *             <dt>HTTP Host header syntax</dt>
- *             <dd>
- *                <p>
- *                   <b>Directory buckets </b> - The HTTP Host header syntax is <code>
- *                      <i>Bucket_name</i>.s3express-<i>az_id</i>.<i>region</i>.amazonaws.com</code>.</p>
- *             </dd>
- *          </dl>
- *          <p>The following operations are related to <code>CreateMultipartUpload</code>:</p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html">UploadPart</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html">CompleteMultipartUpload</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_AbortMultipartUpload.html">AbortMultipartUpload</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html">ListParts</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html">ListMultipartUploads</a>
- *                </p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { S3Client, CreateMultipartUploadCommand } from "@aws-sdk/client-s3"; // ES Modules import
- * // const { S3Client, CreateMultipartUploadCommand } = require("@aws-sdk/client-s3"); // CommonJS import
- * const client = new S3Client(config);
- * const input = { // CreateMultipartUploadRequest
- *   ACL: "private" || "public-read" || "public-read-write" || "authenticated-read" || "aws-exec-read" || "bucket-owner-read" || "bucket-owner-full-control",
- *   Bucket: "STRING_VALUE", // required
- *   CacheControl: "STRING_VALUE",
- *   ContentDisposition: "STRING_VALUE",
- *   ContentEncoding: "STRING_VALUE",
- *   ContentLanguage: "STRING_VALUE",
- *   ContentType: "STRING_VALUE",
- *   Expires: new Date("TIMESTAMP"),
- *   GrantFullControl: "STRING_VALUE",
- *   GrantRead: "STRING_VALUE",
- *   GrantReadACP: "STRING_VALUE",
- *   GrantWriteACP: "STRING_VALUE",
- *   Key: "STRING_VALUE", // required
- *   Metadata: { // Metadata
- *     "<keys>": "STRING_VALUE",
- *   },
- *   ServerSideEncryption: "AES256" || "aws:kms" || "aws:kms:dsse",
- *   StorageClass: "STANDARD" || "REDUCED_REDUNDANCY" || "STANDARD_IA" || "ONEZONE_IA" || "INTELLIGENT_TIERING" || "GLACIER" || "DEEP_ARCHIVE" || "OUTPOSTS" || "GLACIER_IR" || "SNOW" || "EXPRESS_ONEZONE",
- *   WebsiteRedirectLocation: "STRING_VALUE",
- *   SSECustomerAlgorithm: "STRING_VALUE",
- *   SSECustomerKey: "STRING_VALUE",
- *   SSECustomerKeyMD5: "STRING_VALUE",
- *   SSEKMSKeyId: "STRING_VALUE",
- *   SSEKMSEncryptionContext: "STRING_VALUE",
- *   BucketKeyEnabled: true || false,
- *   RequestPayer: "requester",
- *   Tagging: "STRING_VALUE",
- *   ObjectLockMode: "GOVERNANCE" || "COMPLIANCE",
- *   ObjectLockRetainUntilDate: new Date("TIMESTAMP"),
- *   ObjectLockLegalHoldStatus: "ON" || "OFF",
- *   ExpectedBucketOwner: "STRING_VALUE",
- *   ChecksumAlgorithm: "CRC32" || "CRC32C" || "SHA1" || "SHA256",
- * };
- * const command = new CreateMultipartUploadCommand(input);
- * const response = await client.send(command);
- * // { // CreateMultipartUploadOutput
- * //   AbortDate: new Date("TIMESTAMP"),
- * //   AbortRuleId: "STRING_VALUE",
- * //   Bucket: "STRING_VALUE",
- * //   Key: "STRING_VALUE",
- * //   UploadId: "STRING_VALUE",
- * //   ServerSideEncryption: "AES256" || "aws:kms" || "aws:kms:dsse",
- * //   SSECustomerAlgorithm: "STRING_VALUE",
- * //   SSECustomerKeyMD5: "STRING_VALUE",
- * //   SSEKMSKeyId: "STRING_VALUE",
- * //   SSEKMSEncryptionContext: "STRING_VALUE",
- * //   BucketKeyEnabled: true || false,
- * //   RequestCharged: "requester",
- * //   ChecksumAlgorithm: "CRC32" || "CRC32C" || "SHA1" || "SHA256",
- * // };
- *
- * ```
- *
- * @param CreateMultipartUploadCommandInput - {@link CreateMultipartUploadCommandInput}
- * @returns {@link CreateMultipartUploadCommandOutput}
- * @see {@link CreateMultipartUploadCommandInput} for command's `input` shape.
- * @see {@link CreateMultipartUploadCommandOutput} for command's `response` shape.
- * @see {@link S3ClientResolvedConfig | config} for S3Client's `config` shape.
- *
- * @throws {@link S3ServiceException}
- * <p>Base exception class for all service exceptions from S3 service.</p>
- *
- * @example To initiate a multipart upload
- * ```javascript
- * // The following example initiates a multipart upload.
- * const input = {
- *   "Bucket": "examplebucket",
- *   "Key": "largeobject"
- * };
- * const command = new CreateMultipartUploadCommand(input);
- * const response = await client.send(command);
- * /* response ==
- * {
- *   "Bucket": "examplebucket",
- *   "Key": "largeobject",
- *   "UploadId": "ibZBv_75gd9r8lH_gqXatLdxMVpAlj6ZQjEs.OwyF3953YdwbcQnMA2BLGn8Lx12fQNICtMw5KyteFeHw.Sjng--"
- * }
- * *\/
- * // example id: to-initiate-a-multipart-upload-1481836794513
- * ```
- *
- */
-export declare class CreateMultipartUploadCommand extends $Command<CreateMultipartUploadCommandInput, CreateMultipartUploadCommandOutput, S3ClientResolvedConfig> {
-    readonly input: CreateMultipartUploadCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: CreateMultipartUploadCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: S3ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateMultipartUploadCommandInput, CreateMultipartUploadCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
-}