cdk-assets 0.0.0

package/lib/aws-types.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * This file contains a copy of the input and output types from the SDK v3
+ * clients. Instead of exposing the SDK types in the public interface, we
+ * expose these, shielding consumers from breaking changes in a possible
+ * migration to an SDK v4.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EncryptionType = exports.ImageTagMutability = exports.FindingSeverity = exports.ScanStatus = exports.TagStatus = exports.StorageClass = exports.ObjectLockLegalHoldStatus = exports.ObjectLockMode = exports.ObjectCannedACL = exports.ObjectStorageClass = exports.ChecksumAlgorithmIn = exports.RequestCharged = exports.OptionalObjectAttributes = exports.RequestPayer = exports.EncodingType = exports.BucketLocationConstraint = exports.ServerSideEncryption = void 0;
+exports.ServerSideEncryption = {
+    AES256: 'AES256',
+    aws_kms: 'aws:kms',
+    aws_kms_dsse: 'aws:kms:dsse',
+};
+exports.BucketLocationConstraint = {
+    EU: 'EU',
+    af_south_1: 'af-south-1',
+    ap_east_1: 'ap-east-1',
+    ap_northeast_1: 'ap-northeast-1',
+    ap_northeast_2: 'ap-northeast-2',
+    ap_northeast_3: 'ap-northeast-3',
+    ap_south_1: 'ap-south-1',
+    ap_south_2: 'ap-south-2',
+    ap_southeast_1: 'ap-southeast-1',
+    ap_southeast_2: 'ap-southeast-2',
+    ap_southeast_3: 'ap-southeast-3',
+    ca_central_1: 'ca-central-1',
+    cn_north_1: 'cn-north-1',
+    cn_northwest_1: 'cn-northwest-1',
+    eu_central_1: 'eu-central-1',
+    eu_north_1: 'eu-north-1',
+    eu_south_1: 'eu-south-1',
+    eu_south_2: 'eu-south-2',
+    eu_west_1: 'eu-west-1',
+    eu_west_2: 'eu-west-2',
+    eu_west_3: 'eu-west-3',
+    me_south_1: 'me-south-1',
+    sa_east_1: 'sa-east-1',
+    us_east_2: 'us-east-2',
+    us_gov_east_1: 'us-gov-east-1',
+    us_gov_west_1: 'us-gov-west-1',
+    us_west_1: 'us-west-1',
+    us_west_2: 'us-west-2',
+};
+exports.EncodingType = {
+    url: 'url',
+};
+exports.RequestPayer = {
+    requester: 'requester',
+};
+exports.OptionalObjectAttributes = {
+    RESTORE_STATUS: 'RestoreStatus',
+};
+exports.RequestCharged = {
+    requester: 'requester',
+};
+exports.ChecksumAlgorithmIn = {
+    CRC32: 'CRC32',
+    CRC32C: 'CRC32C',
+    SHA1: 'SHA1',
+    SHA256: 'SHA256',
+};
+exports.ObjectStorageClass = {
+    DEEP_ARCHIVE: 'DEEP_ARCHIVE',
+    EXPRESS_ONEZONE: 'EXPRESS_ONEZONE',
+    GLACIER: 'GLACIER',
+    GLACIER_IR: 'GLACIER_IR',
+    INTELLIGENT_TIERING: 'INTELLIGENT_TIERING',
+    ONEZONE_IA: 'ONEZONE_IA',
+    OUTPOSTS: 'OUTPOSTS',
+    REDUCED_REDUNDANCY: 'REDUCED_REDUNDANCY',
+    SNOW: 'SNOW',
+    STANDARD: 'STANDARD',
+    STANDARD_IA: 'STANDARD_IA',
+};
+exports.ObjectCannedACL = {
+    authenticated_read: 'authenticated-read',
+    aws_exec_read: 'aws-exec-read',
+    bucket_owner_full_control: 'bucket-owner-full-control',
+    bucket_owner_read: 'bucket-owner-read',
+    private: 'private',
+    public_read: 'public-read',
+    public_read_write: 'public-read-write',
+};
+exports.ObjectLockMode = {
+    COMPLIANCE: 'COMPLIANCE',
+    GOVERNANCE: 'GOVERNANCE',
+};
+exports.ObjectLockLegalHoldStatus = {
+    OFF: 'OFF',
+    ON: 'ON',
+};
+exports.StorageClass = {
+    DEEP_ARCHIVE: 'DEEP_ARCHIVE',
+    EXPRESS_ONEZONE: 'EXPRESS_ONEZONE',
+    GLACIER: 'GLACIER',
+    GLACIER_IR: 'GLACIER_IR',
+    INTELLIGENT_TIERING: 'INTELLIGENT_TIERING',
+    ONEZONE_IA: 'ONEZONE_IA',
+    OUTPOSTS: 'OUTPOSTS',
+    REDUCED_REDUNDANCY: 'REDUCED_REDUNDANCY',
+    SNOW: 'SNOW',
+    STANDARD: 'STANDARD',
+    STANDARD_IA: 'STANDARD_IA',
+};
+exports.TagStatus = {
+    ANY: 'ANY',
+    TAGGED: 'TAGGED',
+    UNTAGGED: 'UNTAGGED',
+};
+exports.ScanStatus = {
+    ACTIVE: 'ACTIVE',
+    COMPLETE: 'COMPLETE',
+    FAILED: 'FAILED',
+    FINDINGS_UNAVAILABLE: 'FINDINGS_UNAVAILABLE',
+    IN_PROGRESS: 'IN_PROGRESS',
+    PENDING: 'PENDING',
+    SCAN_ELIGIBILITY_EXPIRED: 'SCAN_ELIGIBILITY_EXPIRED',
+    UNSUPPORTED_IMAGE: 'UNSUPPORTED_IMAGE',
+};
+exports.FindingSeverity = {
+    CRITICAL: 'CRITICAL',
+    HIGH: 'HIGH',
+    INFORMATIONAL: 'INFORMATIONAL',
+    LOW: 'LOW',
+    MEDIUM: 'MEDIUM',
+    UNDEFINED: 'UNDEFINED',
+};
+exports.ImageTagMutability = {
+    IMMUTABLE: 'IMMUTABLE',
+    MUTABLE: 'MUTABLE',
+};
+exports.EncryptionType = {
+    AES256: 'AES256',
+    KMS: 'KMS',
+    KMS_DSSE: 'KMS_DSSE',
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-types.js","sourceRoot":"","sources":["aws-types.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * This file contains a copy of the input and output types from the SDK v3\n * clients. Instead of exposing the SDK types in the public interface, we\n * expose these, shielding consumers from breaking changes in a possible\n * migration to an SDK v4.\n */\n\nimport { Readable } from 'stream';\n\nexport interface ResponseMetadata {\n  /**\n   * The status code of the last HTTP response received for this operation.\n   */\n  httpStatusCode?: number;\n  /**\n   * A unique identifier for the last request sent for this operation. Often\n   * requested by AWS service teams to aid in debugging.\n   */\n  requestId?: string;\n  /**\n   * A secondary identifier for the last request sent. Used for debugging.\n   */\n  extendedRequestId?: string;\n  /**\n   * A tertiary identifier for the last request sent. Used for debugging.\n   */\n  cfId?: string;\n  /**\n   * The number of times this operation was attempted.\n   */\n  attempts?: number;\n  /**\n   * The total amount of time (in milliseconds) that was spent waiting between\n   * retry attempts.\n   */\n  totalRetryDelay?: number;\n}\n\nexport interface MetadataBearer {\n  /**\n   * Metadata pertaining to this request.\n   */\n  $metadata: ResponseMetadata;\n}\n\nexport interface GetBucketEncryptionCommandInput {\n  /**\n   * <p>The name of the bucket from which the server-side encryption configuration is\n   *          retrieved.</p>\n   * <p>Note: To supply the Multi-region Access Point (MRAP) to Bucket, you need to install the \"@aws-sdk/signature-v4-crt\" package to your project dependencies.\n   * For more information, please go to https://github.com/aws/aws-sdk-js-v3#known-issues</p>\n   */\n  Bucket: string | undefined;\n  /**\n   * <p>The account ID of the expected bucket owner. If the account ID that you provide does not match the actual owner of the bucket, the request fails with the HTTP status code <code>403 Forbidden</code> (access denied).</p>\n   */\n  ExpectedBucketOwner?: string;\n}\n\nexport const ServerSideEncryption = {\n  AES256: 'AES256',\n  aws_kms: 'aws:kms',\n  aws_kms_dsse: 'aws:kms:dsse',\n} as const;\n\nexport type ServerSideEncryption = (typeof ServerSideEncryption)[keyof typeof ServerSideEncryption];\n\nexport interface ServerSideEncryptionByDefault {\n  /**\n   * <p>Server-side encryption algorithm to use for the default encryption.</p>\n   */\n  SSEAlgorithm: ServerSideEncryption | undefined;\n  /**\n   * <p>Amazon Web Services Key Management Service (KMS) customer Amazon Web Services KMS key ID to use for the default\n   *          encryption. This parameter is allowed if and only if <code>SSEAlgorithm</code> is set to\n   *          <code>aws:kms</code> or <code>aws:kms:dsse</code>.</p>\n   *          <p>You can specify the key ID, key alias, or the Amazon Resource Name (ARN) of the KMS\n   *          key.</p>\n   *          <ul>\n   *             <li>\n   *                <p>Key ID: <code>1234abcd-12ab-34cd-56ef-1234567890ab</code>\n   *                </p>\n   *             </li>\n   *             <li>\n   *                <p>Key ARN: <code>arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab</code>\n   *                </p>\n   *             </li>\n   *             <li>\n   *                <p>Key Alias: <code>alias/alias-name</code>\n   *                </p>\n   *             </li>\n   *          </ul>\n   *          <p>If you use a key ID, you can run into a LogDestination undeliverable error when creating\n   *          a VPC flow log. </p>\n   *          <p>If you are using encryption with cross-account or Amazon Web Services service operations you must use\n   *          a fully qualified KMS key ARN. For more information, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/dev/bucket-encryption.html#bucket-encryption-update-bucket-policy\">Using encryption for cross-account operations</a>.</p>\n   *          <important>\n   *             <p>Amazon S3 only supports symmetric encryption KMS keys. For more information, see <a href=\"https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html\">Asymmetric keys in Amazon Web Services KMS</a> in the <i>Amazon Web Services Key Management Service\n   *                Developer Guide</i>.</p>\n   *          </important>\n   */\n  KMSMasterKeyID?: string;\n}\n\nexport interface ServerSideEncryptionRule {\n  /**\n   * <p>Specifies the default server-side encryption to apply to new objects in the bucket. If a\n   *          PUT Object request doesn't specify any server-side encryption, this default encryption will\n   *          be applied.</p>\n   */\n  ApplyServerSideEncryptionByDefault?: ServerSideEncryptionByDefault;\n  /**\n   * <p>Specifies whether Amazon S3 should use an S3 Bucket Key with server-side encryption using KMS\n   *          (SSE-KMS) for new objects in the bucket. Existing objects are not affected. Setting the\n   *             <code>BucketKeyEnabled</code> element to <code>true</code> causes Amazon S3 to use an S3\n   *          Bucket Key. By default, S3 Bucket Key is not enabled.</p>\n   *          <p>For more information, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/dev/bucket-key.html\">Amazon S3 Bucket Keys</a> in the\n   *             <i>Amazon S3 User Guide</i>.</p>\n   */\n  BucketKeyEnabled?: boolean;\n}\n\nexport interface ServerSideEncryptionConfiguration {\n  /**\n   * <p>Container for information about a particular server-side encryption configuration\n   *          rule.</p>\n   */\n  Rules: ServerSideEncryptionRule[] | undefined;\n}\n\nexport interface GetBucketEncryptionOutput {\n  /**\n   * <p>Specifies the default server-side-encryption configuration.</p>\n   */\n  ServerSideEncryptionConfiguration?: ServerSideEncryptionConfiguration;\n}\n\nexport interface GetBucketEncryptionCommandOutput\n  extends GetBucketEncryptionOutput,\n  MetadataBearer {}\n\nexport interface GetBucketLocationCommandInput {\n  /**\n   * <p>The name of the bucket for which to get the location.</p>\n   *          <p>When you use this API operation with an access point, provide the alias of the access point in place of the bucket name.</p>\n   *          <p>When you use this API operation with an Object Lambda access point, provide the alias of the Object Lambda access point in place of the bucket name.\n   * If the Object Lambda access point alias in a request is not valid, the error code <code>InvalidAccessPointAliasError</code> is returned.\n   * For more information about <code>InvalidAccessPointAliasError</code>, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html#ErrorCodeList\">List of\n   *             Error Codes</a>.</p>\n   * <p>Note: To supply the Multi-region Access Point (MRAP) to Bucket, you need to install the \"@aws-sdk/signature-v4-crt\" package to your project dependencies.\n   * For more information, please go to https://github.com/aws/aws-sdk-js-v3#known-issues</p>\n   */\n  Bucket: string | undefined;\n  /**\n   * <p>The account ID of the expected bucket owner. If the account ID that you provide does not match the actual owner of the bucket, the request fails with the HTTP status code <code>403 Forbidden</code> (access denied).</p>\n   */\n  ExpectedBucketOwner?: string;\n}\n\nexport const BucketLocationConstraint = {\n  EU: 'EU',\n  af_south_1: 'af-south-1',\n  ap_east_1: 'ap-east-1',\n  ap_northeast_1: 'ap-northeast-1',\n  ap_northeast_2: 'ap-northeast-2',\n  ap_northeast_3: 'ap-northeast-3',\n  ap_south_1: 'ap-south-1',\n  ap_south_2: 'ap-south-2',\n  ap_southeast_1: 'ap-southeast-1',\n  ap_southeast_2: 'ap-southeast-2',\n  ap_southeast_3: 'ap-southeast-3',\n  ca_central_1: 'ca-central-1',\n  cn_north_1: 'cn-north-1',\n  cn_northwest_1: 'cn-northwest-1',\n  eu_central_1: 'eu-central-1',\n  eu_north_1: 'eu-north-1',\n  eu_south_1: 'eu-south-1',\n  eu_south_2: 'eu-south-2',\n  eu_west_1: 'eu-west-1',\n  eu_west_2: 'eu-west-2',\n  eu_west_3: 'eu-west-3',\n  me_south_1: 'me-south-1',\n  sa_east_1: 'sa-east-1',\n  us_east_2: 'us-east-2',\n  us_gov_east_1: 'us-gov-east-1',\n  us_gov_west_1: 'us-gov-west-1',\n  us_west_1: 'us-west-1',\n  us_west_2: 'us-west-2',\n} as const;\n\nexport type BucketLocationConstraint =\n  (typeof BucketLocationConstraint)[keyof typeof BucketLocationConstraint];\n\nexport interface GetBucketLocationOutput {\n  /**\n   * <p>Specifies the Region where the bucket resides. For a list of all the Amazon S3 supported\n   *          location constraints by Region, see <a href=\"https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region\">Regions and Endpoints</a>. Buckets in\n   *          Region <code>us-east-1</code> have a LocationConstraint of <code>null</code>.</p>\n   */\n  LocationConstraint?: BucketLocationConstraint;\n}\n\nexport interface GetBucketLocationCommandOutput extends GetBucketLocationOutput, MetadataBearer {}\n\nexport const EncodingType = {\n  url: 'url',\n} as const;\n\nexport type EncodingType = (typeof EncodingType)[keyof typeof EncodingType];\n\nexport const RequestPayer = {\n  requester: 'requester',\n} as const;\n\nexport type RequestPayer = (typeof RequestPayer)[keyof typeof RequestPayer];\n\nexport const OptionalObjectAttributes = {\n  RESTORE_STATUS: 'RestoreStatus',\n} as const;\n\nexport type OptionalObjectAttributes =\n  (typeof OptionalObjectAttributes)[keyof typeof OptionalObjectAttributes];\n\nexport interface ListObjectsV2CommandInput {\n  /**\n   * <p>\n   *             <b>Directory buckets</b> - When you use this operation with a directory bucket, you must use virtual-hosted-style requests in the format <code>\n   *                <i>Bucket_name</i>.s3express-<i>az_id</i>.<i>region</i>.amazonaws.com</code>. Path-style requests are not supported.  Directory bucket names must be unique in the chosen Availability Zone. Bucket names must follow the format <code>\n   *                <i>bucket_base_name</i>--<i>az-id</i>--x-s3</code> (for example, <code>\n   *                <i>DOC-EXAMPLE-BUCKET</i>--<i>usw2-az1</i>--x-s3</code>). For information about bucket naming\n   *          restrictions, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-bucket-naming-rules.html\">Directory bucket naming\n   *             rules</a> in the <i>Amazon S3 User Guide</i>.</p>\n   *          <p>\n   *             <b>Access points</b> - When you use this action with an access point, you must provide the alias of the access point in place of the bucket name or specify the access point ARN. When using the access point ARN, you must direct requests to the access point hostname. The access point hostname takes the form <i>AccessPointName</i>-<i>AccountId</i>.s3-accesspoint.<i>Region</i>.amazonaws.com. When using this action with an access point through the Amazon Web Services SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-access-points.html\">Using access points</a> in the <i>Amazon S3 User Guide</i>.</p>\n   *          <note>\n   *             <p>Access points and Object Lambda access points are not supported by directory buckets.</p>\n   *          </note>\n   *          <p>\n   *             <b>S3 on Outposts</b> - When you use this action with Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form <code>\n   *                <i>AccessPointName</i>-<i>AccountId</i>.<i>outpostID</i>.s3-outposts.<i>Region</i>.amazonaws.com</code>. When you use this action with S3 on Outposts through the Amazon Web Services SDKs, you provide the Outposts access point ARN in place of the bucket name. For more information about S3 on Outposts ARNs, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/userguide/S3onOutposts.html\">What is S3 on Outposts?</a> in the <i>Amazon S3 User Guide</i>.</p>\n   * <p>Note: To supply the Multi-region Access Point (MRAP) to Bucket, you need to install the \"@aws-sdk/signature-v4-crt\" package to your project dependencies.\n   * For more information, please go to https://github.com/aws/aws-sdk-js-v3#known-issues</p>\n   */\n  Bucket: string | undefined;\n  /**\n   * <p>A delimiter is a character that you use to group keys.</p>\n   *          <note>\n   *             <ul>\n   *                <li>\n   *                   <p>\n   *                      <b>Directory buckets</b> - For directory buckets, <code>/</code> is the only supported delimiter.</p>\n   *                </li>\n   *                <li>\n   *                   <p>\n   *                      <b>Directory buckets </b> - When you query <code>ListObjectsV2</code> with a delimiter during in-progress multipart uploads, the\n   *             <code>CommonPrefixes</code> response parameter contains the prefixes that are associated with the in-progress multipart uploads.\n   *                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>\n   *                </li>\n   *             </ul>\n   *          </note>\n   */\n  Delimiter?: string;\n  /**\n   * <p>Encoding type used by Amazon S3 to encode the <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html\">object keys</a> in the response.\n   *          Responses are encoded only in UTF-8. An object key can contain any Unicode character.\n   *          However, the XML 1.0 parser can't parse certain characters, such as characters with an\n   *          ASCII value from 0 to 10. For characters that aren't supported in XML 1.0, you can add this\n   *          parameter to request that Amazon S3 encode the keys in the response. For more information about\n   *          characters to avoid in object key names, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-guidelines\">Object key naming\n   *             guidelines</a>.</p>\n   *          <note>\n   *             <p>When using the URL encoding type, non-ASCII characters that are used in an object's\n   *             key name will be percent-encoded according to UTF-8 code values. For example, the object\n   *             <code>test_file(3).png</code> will appear as\n   *             <code>test_file%283%29.png</code>.</p>\n   *          </note>\n   */\n  EncodingType?: EncodingType;\n  /**\n   * <p>Sets the maximum number of keys returned in the response. By default, the action returns\n   *          up to 1,000 key names. The response might contain fewer keys but will never contain\n   *          more.</p>\n   */\n  MaxKeys?: number;\n  /**\n   * <p>Limits the response to keys that begin with the specified prefix.</p>\n   *          <note>\n   *             <p>\n   *                <b>Directory buckets</b> - For directory buckets, only prefixes that end in a delimiter (<code>/</code>) are supported.</p>\n   *          </note>\n   */\n  Prefix?: string;\n  /**\n   * <p>\n   *             <code>ContinuationToken</code> indicates to Amazon S3 that the list is being continued on\n   *          this bucket with a token. <code>ContinuationToken</code> is obfuscated and is not a real\n   *          key. You can use this <code>ContinuationToken</code> for pagination of the list results.  </p>\n   */\n  ContinuationToken?: string;\n  /**\n   * <p>The owner field is not present in <code>ListObjectsV2</code> by default. If you want to\n   *          return the owner field with each key in the result, then set the <code>FetchOwner</code>\n   *          field to <code>true</code>.</p>\n   *          <note>\n   *             <p>\n   *                <b>Directory buckets</b> - For directory buckets, the bucket owner is returned as the object owner for all objects.</p>\n   *          </note>\n   */\n  FetchOwner?: boolean;\n  /**\n   * <p>StartAfter is where you want Amazon S3 to start listing from. Amazon S3 starts listing after this\n   *          specified key. StartAfter can be any key in the bucket.</p>\n   *          <note>\n   *             <p>This functionality is not supported for directory buckets.</p>\n   *          </note>\n   */\n  StartAfter?: string;\n  /**\n   * <p>Confirms that the requester knows that she or he will be charged for the list objects\n   *          request in V2 style. Bucket owners need not specify this parameter in their\n   *          requests.</p>\n   *          <note>\n   *             <p>This functionality is not supported for directory buckets.</p>\n   *          </note>\n   */\n  RequestPayer?: RequestPayer;\n  /**\n   * <p>The account ID of the expected bucket owner. If the account ID that you provide does not match the actual owner of the bucket, the request fails with the HTTP status code <code>403 Forbidden</code> (access denied).</p>\n   */\n  ExpectedBucketOwner?: string;\n  /**\n   * <p>Specifies the optional fields that you want returned in the response. Fields that you do\n   *          not specify are not returned.</p>\n   *          <note>\n   *             <p>This functionality is not supported for directory buckets.</p>\n   *          </note>\n   */\n  OptionalObjectAttributes?: OptionalObjectAttributes[];\n}\n\nexport const RequestCharged = {\n  requester: 'requester',\n} as const;\n\nexport type RequestCharged = (typeof RequestCharged)[keyof typeof RequestCharged];\n\nexport const ChecksumAlgorithmIn = {\n  CRC32: 'CRC32',\n  CRC32C: 'CRC32C',\n  SHA1: 'SHA1',\n  SHA256: 'SHA256',\n} as const;\n\nexport type ChecksumAlgorithmIn = (typeof ChecksumAlgorithmIn)[keyof typeof ChecksumAlgorithmIn];\n\nexport type ChecksumAlgorithmOut = string;\n\nexport const ObjectStorageClass = {\n  DEEP_ARCHIVE: 'DEEP_ARCHIVE',\n  EXPRESS_ONEZONE: 'EXPRESS_ONEZONE',\n  GLACIER: 'GLACIER',\n  GLACIER_IR: 'GLACIER_IR',\n  INTELLIGENT_TIERING: 'INTELLIGENT_TIERING',\n  ONEZONE_IA: 'ONEZONE_IA',\n  OUTPOSTS: 'OUTPOSTS',\n  REDUCED_REDUNDANCY: 'REDUCED_REDUNDANCY',\n  SNOW: 'SNOW',\n  STANDARD: 'STANDARD',\n  STANDARD_IA: 'STANDARD_IA',\n} as const;\n\nexport type ObjectStorageClass = (typeof ObjectStorageClass)[keyof typeof ObjectStorageClass];\n\nexport interface Owner {\n  /**\n   * <p>Container for the display name of the owner. This value is only supported in the\n   *          following Amazon Web Services Regions:</p>\n   *          <ul>\n   *             <li>\n   *                <p>US East (N. Virginia)</p>\n   *             </li>\n   *             <li>\n   *                <p>US West (N. California)</p>\n   *             </li>\n   *             <li>\n   *                <p>US West (Oregon)</p>\n   *             </li>\n   *             <li>\n   *                <p>Asia Pacific (Singapore)</p>\n   *             </li>\n   *             <li>\n   *                <p>Asia Pacific (Sydney)</p>\n   *             </li>\n   *             <li>\n   *                <p>Asia Pacific (Tokyo)</p>\n   *             </li>\n   *             <li>\n   *                <p>Europe (Ireland)</p>\n   *             </li>\n   *             <li>\n   *                <p>South America (São Paulo)</p>\n   *             </li>\n   *          </ul>\n   *          <note>\n   *             <p>This functionality is not supported for directory buckets.</p>\n   *          </note>\n   */\n  DisplayName?: string;\n\n  /**\n   * <p>Container for the ID of the owner.</p>\n   */\n  ID?: string;\n}\n\nexport interface RestoreStatus {\n  /**\n   * <p>Specifies whether the object is currently being restored. If the object restoration is\n   *          in progress, the header returns the value <code>TRUE</code>. For example:</p>\n   *          <p>\n   *             <code>x-amz-optional-object-attributes: IsRestoreInProgress=\"true\"</code>\n   *          </p>\n   *          <p>If the object restoration has completed, the header returns the value\n   *          <code>FALSE</code>. For example:</p>\n   *          <p>\n   *             <code>x-amz-optional-object-attributes: IsRestoreInProgress=\"false\",\n   *             RestoreExpiryDate=\"2012-12-21T00:00:00.000Z\"</code>\n   *          </p>\n   *          <p>If the object hasn't been restored, there is no header response.</p>\n   */\n  IsRestoreInProgress?: boolean;\n\n  /**\n   * <p>Indicates when the restored copy will expire. This value is populated only if the object\n   *          has already been restored. For example:</p>\n   *          <p>\n   *             <code>x-amz-optional-object-attributes: IsRestoreInProgress=\"false\",\n   *             RestoreExpiryDate=\"2012-12-21T00:00:00.000Z\"</code>\n   *          </p>\n   */\n  RestoreExpiryDate?: Date;\n}\n\n/**\n * Return one of 2 types, depending on whether we are passing values in or out\n *\n * Use as follows:\n *\n * ```ts\n * interface ContainingType<Dir> {\n *    field: InOut<Dir, FieldTypeIn, FieldTypeOut>;\n * }\n * ```\n */\ntype InOut<Dir, I, O> = Dir extends 'in' ? I : Dir extends 'out' ? O : never;\n\nexport interface _Object<Dir> {\n  /**\n   * <p>The name that you assign to an object. You use the object key to retrieve the\n   *          object.</p>\n   */\n  Key?: string;\n\n  /**\n   * <p>Creation date of the object.</p>\n   */\n  LastModified?: Date;\n\n  /**\n   * <p>The entity tag is a hash of the object. The ETag reflects changes only to the contents\n   *          of an object, not its metadata. The ETag may or may not be an MD5 digest of the object\n   *          data. Whether or not it is depends on how the object was created and how it is encrypted as\n   *          described below:</p>\n   *          <ul>\n   *             <li>\n   *                <p>Objects created by the PUT Object, POST Object, or Copy operation, or through the\n   *                Amazon Web Services Management Console, and are encrypted by SSE-S3 or plaintext, have ETags that\n   *                are an MD5 digest of their object data.</p>\n   *             </li>\n   *             <li>\n   *                <p>Objects created by the PUT Object, POST Object, or Copy operation, or through the\n   *                Amazon Web Services Management Console, and are encrypted by SSE-C or SSE-KMS, have ETags that are\n   *                not an MD5 digest of their object data.</p>\n   *             </li>\n   *             <li>\n   *                <p>If an object is created by either the Multipart Upload or Part Copy operation, the\n   *                ETag is not an MD5 digest, regardless of the method of encryption. If an object is\n   *                larger than 16 MB, the Amazon Web Services Management Console will upload or copy that object as a\n   *                Multipart Upload, and therefore the ETag will not be an MD5 digest.</p>\n   *             </li>\n   *          </ul>\n   *          <note>\n   *             <p>\n   *                <b>Directory buckets</b> - MD5 is not supported by directory buckets.</p>\n   *          </note>\n   */\n  ETag?: string;\n\n  /**\n   * <p>The algorithm that was used to create a checksum of the object.</p>\n   */\n  ChecksumAlgorithm?: InOut<Dir, ChecksumAlgorithmIn, ChecksumAlgorithmOut>[];\n\n  /**\n   * <p>Size in bytes of the object</p>\n   */\n  Size?: number;\n\n  /**\n   * <p>The class of storage used to store the object.</p>\n   *          <note>\n   *             <p>\n   *                <b>Directory buckets</b> - Only the S3 Express One Zone storage class is supported by directory buckets to store objects.</p>\n   *          </note>\n   */\n  StorageClass?: ObjectStorageClass;\n\n  /**\n   * <p>The owner of the object</p>\n   *          <note>\n   *             <p>\n   *                <b>Directory buckets</b> - The bucket owner is returned as the object owner.</p>\n   *          </note>\n   */\n  Owner?: Owner;\n\n  /**\n   * <p>Specifies the restoration status of an object. Objects in certain storage classes must\n   *          be restored before they can be retrieved. For more information about these storage classes\n   *          and how to work with archived objects, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/userguide/archived-objects.html\"> Working with archived\n   *             objects</a> in the <i>Amazon S3 User Guide</i>.</p>\n   *          <note>\n   *             <p>This functionality is not supported for directory buckets. Only the S3 Express One Zone storage class is supported by directory buckets to store objects.</p>\n   *          </note>\n   */\n  RestoreStatus?: RestoreStatus;\n}\n\nexport interface CommonPrefix {\n  /**\n   * <p>Container for the specified common prefix.</p>\n   */\n  Prefix?: string;\n}\n\nexport interface ListObjectsV2Output {\n  /**\n   * <p>Set to <code>false</code> if all of the results were returned. Set to <code>true</code>\n   *          if more keys are available to return. If the number of results exceeds that specified by\n   *             <code>MaxKeys</code>, all of the results might not be returned.</p>\n   */\n  IsTruncated?: boolean;\n  /**\n   * <p>Metadata about each object returned.</p>\n   */\n  Contents?: _Object<'out'>[];\n  /**\n   * <p>The bucket name.</p>\n   */\n  Name?: string;\n  /**\n   * <p>Keys that begin with the indicated prefix.</p>\n   *          <note>\n   *             <p>\n   *                <b>Directory buckets</b> - For directory buckets, only prefixes that end in a delimiter (<code>/</code>) are supported.</p>\n   *          </note>\n   */\n  Prefix?: string;\n  /**\n   * <p>Causes keys that contain the same string between the <code>prefix</code> and the first\n   *          occurrence of the delimiter to be rolled up into a single result element in the\n   *             <code>CommonPrefixes</code> collection. These rolled-up keys are not returned elsewhere\n   *          in the response. Each rolled-up result counts as only one return against the\n   *             <code>MaxKeys</code> value.</p>\n   *          <note>\n   *             <p>\n   *                <b>Directory buckets</b> - For directory buckets, <code>/</code> is the only supported delimiter.</p>\n   *          </note>\n   */\n  Delimiter?: string;\n  /**\n   * <p>Sets the maximum number of keys returned in the response. By default, the action returns\n   *          up to 1,000 key names. The response might contain fewer keys but will never contain\n   *          more.</p>\n   */\n  MaxKeys?: number;\n  /**\n   * <p>All of the keys (up to 1,000) that share the same prefix are grouped together. When counting the total numbers of returns by this API operation,\n   *          this group of keys is considered as one item.</p>\n   *          <p>A response can contain <code>CommonPrefixes</code> only if you specify a\n   *          delimiter.</p>\n   *          <p>\n   *             <code>CommonPrefixes</code> contains all (if there are any) keys between\n   *             <code>Prefix</code> and the next occurrence of the string specified by a\n   *          delimiter.</p>\n   *          <p>\n   *             <code>CommonPrefixes</code> lists keys that act like subdirectories in the directory\n   *          specified by <code>Prefix</code>.</p>\n   *          <p>For example, if the prefix is <code>notes/</code> and the delimiter is a slash\n   *             (<code>/</code>) as in <code>notes/summer/july</code>, the common prefix is\n   *             <code>notes/summer/</code>. All of the keys that roll up into a common prefix count as a\n   *          single return when calculating the number of returns. </p>\n   *          <note>\n   *             <ul>\n   *                <li>\n   *                   <p>\n   *                      <b>Directory buckets</b> - For directory buckets, only prefixes that end in a delimiter (<code>/</code>) are supported.</p>\n   *                </li>\n   *                <li>\n   *                   <p>\n   *                      <b>Directory buckets </b> - When you query <code>ListObjectsV2</code> with a delimiter during in-progress multipart uploads, the\n   *                <code>CommonPrefixes</code> response parameter contains the prefixes that are associated with the in-progress multipart uploads.\n   *                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>\n   *                </li>\n   *             </ul>\n   *          </note>\n   */\n  CommonPrefixes?: CommonPrefix[];\n  /**\n   * <p>Encoding type used by Amazon S3 to encode object key names in the XML response.</p>\n   *          <p>If you specify the <code>encoding-type</code> request parameter, Amazon S3 includes this\n   *          element in the response, and returns encoded key name values in the following response\n   *          elements:</p>\n   *          <p>\n   *             <code>Delimiter, Prefix, Key,</code> and <code>StartAfter</code>.</p>\n   */\n  EncodingType?: EncodingType;\n  /**\n   * <p>\n   *             <code>KeyCount</code> is the number of keys returned with this request.\n   *             <code>KeyCount</code> will always be less than or equal to the <code>MaxKeys</code>\n   *          field. For example, if you ask for 50 keys, your result will include 50 keys or\n   *          fewer.</p>\n   */\n  KeyCount?: number;\n  /**\n   * <p> If <code>ContinuationToken</code> was sent with the request, it is included in the\n   *          response. You can use the returned <code>ContinuationToken</code> for pagination of the list response. You can use this <code>ContinuationToken</code> for pagination of the list results. </p>\n   */\n  ContinuationToken?: string;\n  /**\n   * <p>\n   *             <code>NextContinuationToken</code> is sent when <code>isTruncated</code> is true, which\n   *          means there are more keys in the bucket that can be listed. The next list requests to Amazon S3\n   *          can be continued with this <code>NextContinuationToken</code>.\n   *             <code>NextContinuationToken</code> is obfuscated and is not a real key</p>\n   */\n  NextContinuationToken?: string;\n  /**\n   * <p>If StartAfter was sent with the request, it is included in the response.</p>\n   *          <note>\n   *             <p>This functionality is not supported for directory buckets.</p>\n   *          </note>\n   */\n  StartAfter?: string;\n  /**\n   * <p>If present, indicates that the requester was successfully charged for the\n   *          request.</p>\n   *          <note>\n   *             <p>This functionality is not supported for directory buckets.</p>\n   *          </note>\n   */\n  RequestCharged?: RequestCharged;\n}\n\nexport interface ListObjectsV2CommandOutput extends ListObjectsV2Output, MetadataBearer {}\n\nexport const ObjectCannedACL = {\n  authenticated_read: 'authenticated-read',\n  aws_exec_read: 'aws-exec-read',\n  bucket_owner_full_control: 'bucket-owner-full-control',\n  bucket_owner_read: 'bucket-owner-read',\n  private: 'private',\n  public_read: 'public-read',\n  public_read_write: 'public-read-write',\n} as const;\n\nexport type ObjectCannedACL = (typeof ObjectCannedACL)[keyof typeof ObjectCannedACL];\n\nexport const ObjectLockMode = {\n  COMPLIANCE: 'COMPLIANCE',\n  GOVERNANCE: 'GOVERNANCE',\n} as const;\n\nexport type ObjectLockMode = (typeof ObjectLockMode)[keyof typeof ObjectLockMode];\n\nexport const ObjectLockLegalHoldStatus = {\n  OFF: 'OFF',\n  ON: 'ON',\n} as const;\n\nexport type ObjectLockLegalHoldStatus =\n  (typeof ObjectLockLegalHoldStatus)[keyof typeof ObjectLockLegalHoldStatus];\n\nexport const StorageClass = {\n  DEEP_ARCHIVE: 'DEEP_ARCHIVE',\n  EXPRESS_ONEZONE: 'EXPRESS_ONEZONE',\n  GLACIER: 'GLACIER',\n  GLACIER_IR: 'GLACIER_IR',\n  INTELLIGENT_TIERING: 'INTELLIGENT_TIERING',\n  ONEZONE_IA: 'ONEZONE_IA',\n  OUTPOSTS: 'OUTPOSTS',\n  REDUCED_REDUNDANCY: 'REDUCED_REDUNDANCY',\n  SNOW: 'SNOW',\n  STANDARD: 'STANDARD',\n  STANDARD_IA: 'STANDARD_IA',\n} as const;\n\nexport type StorageClass = (typeof StorageClass)[keyof typeof StorageClass];\n\nexport interface Identity {\n  /**\n   * A `Date` when the identity or credential will no longer be accepted.\n   */\n  readonly expiration?: Date;\n}\n\nexport interface IdentityProvider<IdentityT extends Identity> {\n  (identityProperties?: Record<string, any>): Promise<IdentityT>;\n}\n\nexport interface AwsCredentialIdentity extends Identity {\n  /**\n   * AWS access key ID\n   */\n  readonly accessKeyId: string;\n  /**\n   * AWS secret access key\n   */\n  readonly secretAccessKey: string;\n  /**\n   * A security or session token to use with these credentials. Usually\n   * present for temporary credentials.\n   */\n  readonly sessionToken?: string;\n  /**\n   * AWS credential scope for this set of credentials.\n   */\n  readonly credentialScope?: string;\n  /**\n   * AWS accountId.\n   */\n  readonly accountId?: string;\n}\n\nexport type AwsCredentialIdentityProvider = IdentityProvider<AwsCredentialIdentity>;\n\nexport interface PutObjectRequest {\n  /**\n   * <p>The canned ACL to apply to the object. For more information, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#CannedACL\">Canned\n   *          ACL</a> in the <i>Amazon S3 User Guide</i>.</p>\n   *          <p>When adding a new object, you can use headers to grant ACL-based permissions to\n   *          individual Amazon Web Services accounts or to predefined groups defined by Amazon S3. These permissions are\n   *          then added to the ACL on the object. By default, all objects are private. Only the owner\n   *          has full access control. For more information, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html\">Access Control List (ACL) Overview</a>\n   *          and <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-using-rest-api.html\">Managing\n   *             ACLs Using the REST API</a> in the <i>Amazon S3 User Guide</i>.</p>\n   *          <p>If the bucket that you're uploading objects to uses the bucket owner enforced setting\n   *          for S3 Object Ownership, ACLs are disabled and no longer affect permissions. Buckets that\n   *          use this setting only accept PUT requests that don't specify an ACL or PUT requests that\n   *          specify bucket owner full control ACLs, such as the <code>bucket-owner-full-control</code>\n   *          canned ACL or an equivalent form of this ACL expressed in the XML format. PUT requests that\n   *          contain other ACLs (for example, custom grants to certain Amazon Web Services accounts) fail and return a\n   *          <code>400</code> error with the error code <code>AccessControlListNotSupported</code>.\n   *          For more information, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/userguide/about-object-ownership.html\"> Controlling ownership of\n   *             objects and disabling ACLs</a> in the <i>Amazon S3 User Guide</i>.</p>\n   *          <note>\n   *             <ul>\n   *                <li>\n   *                   <p>This functionality is not supported for directory buckets.</p>\n   *                </li>\n   *                <li>\n   *                   <p>This functionality is not supported for Amazon S3 on Outposts.</p>\n   *                </li>\n   *             </ul>\n   *          </note>\n   */\n  ACL?: ObjectCannedACL;\n  /**\n   * <p>Object data.</p>\n   */\n  Body?: Readable;\n  /**\n   * <p>The bucket name to which the PUT action was initiated. </p>\n   *          <p>\n   *             <b>Directory buckets</b> - When you use this operation with a directory bucket, you must use virtual-hosted-style requests in the format <code>\n   *                <i>Bucket_name</i>.s3express-<i>az_id</i>.<i>region</i>.amazonaws.com</code>. Path-style requests are not supported.  Directory bucket names must be unique in the chosen Availability Zone. Bucket names must follow the format <code>\n   *                <i>bucket_base_name</i>--<i>az-id</i>--x-s3</code> (for example, <code>\n   *                <i>DOC-EXAMPLE-BUCKET</i>--<i>usw2-az1</i>--x-s3</code>). For information about bucket naming\n   *          restrictions, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-bucket-naming-rules.html\">Directory bucket naming\n   *             rules</a> in the <i>Amazon S3 User Guide</i>.</p>\n   *          <p>\n   *             <b>Access points</b> - When you use this action with an access point, you must provide the alias of the access point in place of the bucket name or specify the access point ARN. When using the access point ARN, you must direct requests to the access point hostname. The access point hostname takes the form <i>AccessPointName</i>-<i>AccountId</i>.s3-accesspoint.<i>Region</i>.amazonaws.com. When using this action with an access point through the Amazon Web Services SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-access-points.html\">Using access points</a> in the <i>Amazon S3 User Guide</i>.</p>\n   *          <note>\n   *             <p>Access points and Object Lambda access points are not supported by directory buckets.</p>\n   *          </note>\n   *          <p>\n   *             <b>S3 on Outposts</b> - When you use this action with Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form <code>\n   *                <i>AccessPointName</i>-<i>AccountId</i>.<i>outpostID</i>.s3-outposts.<i>Region</i>.amazonaws.com</code>. When you use this action with S3 on Outposts through the Amazon Web Services SDKs, you provide the Outposts access point ARN in place of the bucket name. For more information about S3 on Outposts ARNs, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/userguide/S3onOutposts.html\">What is S3 on Outposts?</a> in the <i>Amazon S3 User Guide</i>.</p>\n   * <p>Note: To supply the Multi-region Access Point (MRAP) to Bucket, you need to install the \"@aws-sdk/signature-v4-crt\" package to your project dependencies.\n   * For more information, please go to https://github.com/aws/aws-sdk-js-v3#known-issues</p>\n   */\n  Bucket: string | undefined;\n  /**\n   * <p>Can be used to specify caching behavior along the request/reply chain. For more\n   *          information, see <a href=\"http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9\">http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9</a>.</p>\n   */\n  CacheControl?: string;\n  /**\n   * <p>Specifies presentational information for the object. For more information, see <a href=\"https://www.rfc-editor.org/rfc/rfc6266#section-4\">https://www.rfc-editor.org/rfc/rfc6266#section-4</a>.</p>\n   */\n  ContentDisposition?: string;\n  /**\n   * <p>Specifies what content encodings have been applied to the object and thus what decoding\n   *          mechanisms must be applied to obtain the media-type referenced by the Content-Type header\n   *          field. For more information, see <a href=\"https://www.rfc-editor.org/rfc/rfc9110.html#field.content-encoding\">https://www.rfc-editor.org/rfc/rfc9110.html#field.content-encoding</a>.</p>\n   */\n  ContentEncoding?: string;\n  /**\n   * <p>The language the content is in.</p>\n   */\n  ContentLanguage?: string;\n  /**\n   * <p>Size of the body in bytes. This parameter is useful when the size of the body cannot be\n   *          determined automatically. For more information, see <a href=\"https://www.rfc-editor.org/rfc/rfc9110.html#name-content-length\">https://www.rfc-editor.org/rfc/rfc9110.html#name-content-length</a>.</p>\n   */\n  ContentLength?: number;\n  /**\n   * <p>The base64-encoded 128-bit MD5 digest of the message (without the headers) according to\n   *          RFC 1864. This header can be used as a message integrity check to verify that the data is\n   *          the same data that was originally sent. Although it is optional, we recommend using the\n   *          Content-MD5 mechanism as an end-to-end integrity check. For more information about REST\n   *          request authentication, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/dev/RESTAuthentication.html\">REST Authentication</a>.</p>\n   *          <note>\n   *             <p>The <code>Content-MD5</code> header is required for any request to upload an\n   *          object with a retention period configured using Amazon S3 Object Lock. For more\n   *          information about Amazon S3 Object Lock, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/dev/object-lock-overview.html\">Amazon S3 Object Lock\n   *             Overview</a> in the <i>Amazon S3 User Guide</i>. </p>\n   *          </note>\n   *          <note>\n   *             <p>This functionality is not supported for directory buckets.</p>\n   *          </note>\n   */\n  ContentMD5?: string;\n  /**\n   * <p>A standard MIME type describing the format of the contents. For more information, see\n   *             <a href=\"https://www.rfc-editor.org/rfc/rfc9110.html#name-content-type\">https://www.rfc-editor.org/rfc/rfc9110.html#name-content-type</a>.</p>\n   */\n  ContentType?: string;\n  /**\n   * <p>Indicates the algorithm used to create the checksum for the object when you use the SDK. This header will not provide any\n   *     additional functionality if you don't use the SDK. When you send this header, there must be a corresponding <code>x-amz-checksum-<i>algorithm</i>\n   *             </code> or\n   *     <code>x-amz-trailer</code> header sent. Otherwise, Amazon S3 fails the request with the HTTP status code <code>400 Bad Request</code>.</p>\n   *          <p>For the <code>x-amz-checksum-<i>algorithm</i>\n   *             </code> header, replace <code>\n   *                <i>algorithm</i>\n   *             </code> with the supported algorithm from the following list: </p>\n   *          <ul>\n   *             <li>\n   *                <p>CRC32</p>\n   *             </li>\n   *             <li>\n   *                <p>CRC32C</p>\n   *             </li>\n   *             <li>\n   *                <p>SHA1</p>\n   *             </li>\n   *             <li>\n   *                <p>SHA256</p>\n   *             </li>\n   *          </ul>\n   *          <p>For more\n   *     information, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html\">Checking object integrity</a> in\n   *     the <i>Amazon S3 User Guide</i>.</p>\n   *          <p>If the individual checksum value you provide through <code>x-amz-checksum-<i>algorithm</i>\n   *             </code> doesn't match the checksum algorithm you set through <code>x-amz-sdk-checksum-algorithm</code>,  Amazon S3 ignores any provided\n   *             <code>ChecksumAlgorithm</code> parameter and uses the checksum algorithm that matches the provided value in <code>x-amz-checksum-<i>algorithm</i>\n   *             </code>.</p>\n   *          <note>\n   *             <p>For directory buckets, when you use Amazon Web Services SDKs, <code>CRC32</code> is the default checksum algorithm that's used for performance.</p>\n   *          </note>\n   */\n  ChecksumAlgorithm?: ChecksumAlgorithmIn;\n  /**\n   * <p>This header can be used as a data integrity check to verify that the data received is the same data that was originally sent.\n   *     This header specifies the base64-encoded, 32-bit CRC32 checksum of the object. For more information, see\n   *     <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html\">Checking object integrity</a> in the\n   *     <i>Amazon S3 User Guide</i>.</p>\n   */\n  ChecksumCRC32?: string;\n  /**\n   * <p>This header can be used as a data integrity check to verify that the data received is the same data that was originally sent.\n   *     This header specifies the base64-encoded, 32-bit CRC32C checksum of the object. For more information, see\n   *     <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html\">Checking object integrity</a> in the\n   *     <i>Amazon S3 User Guide</i>.</p>\n   */\n  ChecksumCRC32C?: string;\n  /**\n   * <p>This header can be used as a data integrity check to verify that the data received is the same data that was originally sent.\n   *     This header specifies the base64-encoded, 160-bit SHA-1 digest of the object. For more information, see\n   *     <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html\">Checking object integrity</a> in the\n   *     <i>Amazon S3 User Guide</i>.</p>\n   */\n  ChecksumSHA1?: string;\n  /**\n   * <p>This header can be used as a data integrity check to verify that the data received is the same data that was originally sent.\n   *     This header specifies the base64-encoded, 256-bit SHA-256 digest of the object. For more information, see\n   *     <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html\">Checking object integrity</a> in the\n   *     <i>Amazon S3 User Guide</i>.</p>\n   */\n  ChecksumSHA256?: string;\n  /**\n   * <p>The date and time at which the object is no longer cacheable. For more information, see\n   *             <a href=\"https://www.rfc-editor.org/rfc/rfc7234#section-5.3\">https://www.rfc-editor.org/rfc/rfc7234#section-5.3</a>.</p>\n   */\n  Expires?: Date;\n  /**\n   * <p>Uploads the object only if the object key name does not already exist in the bucket specified. Otherwise, Amazon S3 returns a <code>412 Precondition Failed</code> error.</p>\n   *          <p>If a conflicting operation occurs during the upload S3 returns a <code>409 ConditionalRequestConflict</code> response. On a 409 failure you should retry the upload.</p>\n   *          <p>Expects the '*' (asterisk) character.</p>\n   *          <p>For more information about conditional requests, see <a href=\"https://tools.ietf.org/html/rfc7232\">RFC 7232</a>, or <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/userguide/conditional-requests.html\">Conditional requests</a> in the <i>Amazon S3 User Guide</i>.</p>\n   */\n  IfNoneMatch?: string;\n  /**\n   * <p>Gives the grantee READ, READ_ACP, and WRITE_ACP permissions on the object.</p>\n   *          <note>\n   *             <ul>\n   *                <li>\n   *                   <p>This functionality is not supported for directory buckets.</p>\n   *                </li>\n   *                <li>\n   *                   <p>This functionality is not supported for Amazon S3 on Outposts.</p>\n   *                </li>\n   *             </ul>\n   *          </note>\n   */\n  GrantFullControl?: string;\n  /**\n   * <p>Allows grantee to read the object data and its metadata.</p>\n   *          <note>\n   *             <ul>\n   *                <li>\n   *                   <p>This functionality is not supported for directory buckets.</p>\n   *                </li>\n   *                <li>\n   *                   <p>This functionality is not supported for Amazon S3 on Outposts.</p>\n   *                </li>\n   *             </ul>\n   *          </note>\n   */\n  GrantRead?: string;\n  /**\n   * <p>Allows grantee to read the object ACL.</p>\n   *          <note>\n   *             <ul>\n   *                <li>\n   *                   <p>This functionality is not supported for directory buckets.</p>\n   *                </li>\n   *                <li>\n   *                   <p>This functionality is not supported for Amazon S3 on Outposts.</p>\n   *                </li>\n   *             </ul>\n   *          </note>\n   */\n  GrantReadACP?: string;\n  /**\n   * <p>Allows grantee to write the ACL for the applicable object.</p>\n   *          <note>\n   *             <ul>\n   *                <li>\n   *                   <p>This functionality is not supported for directory buckets.</p>\n   *                </li>\n   *                <li>\n   *                   <p>This functionality is not supported for Amazon S3 on Outposts.</p>\n   *                </li>\n   *             </ul>\n   *          </note>\n   */\n  GrantWriteACP?: string;\n  /**\n   * <p>Object key for which the PUT action was initiated.</p>\n   */\n  Key: string | undefined;\n  /**\n   * <p>A map of metadata to store with the object in S3.</p>\n   */\n  Metadata?: Record<string, string>;\n  /**\n   * <p>The server-side encryption algorithm that was used when you store this object in Amazon S3 (for example,\n   *             <code>AES256</code>, <code>aws:kms</code>, <code>aws:kms:dsse</code>).</p>\n   *          <p>\n   *             <b>General purpose buckets </b> - You have four mutually exclusive options to protect data using server-side encryption in\n   *                Amazon S3, depending on how you choose to manage the encryption keys. Specifically, the\n   *                encryption key options are Amazon S3 managed keys (SSE-S3), Amazon Web Services KMS keys (SSE-KMS or\n   *                DSSE-KMS), and customer-provided keys (SSE-C). Amazon S3 encrypts data with server-side\n   *                encryption by using Amazon S3 managed keys (SSE-S3) by default. You can optionally tell Amazon S3 to\n   *                encrypt data at rest by using server-side encryption with other key options. For more\n   *                information, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingServerSideEncryption.html\">Using Server-Side\n   *                   Encryption</a> in the <i>Amazon S3 User Guide</i>.</p>\n   *          <p>\n   *             <b>Directory buckets </b> - For directory buckets, only the server-side encryption with Amazon S3 managed keys (SSE-S3) (<code>AES256</code>) value is supported.</p>\n   */\n  ServerSideEncryption?: ServerSideEncryption;\n  /**\n   * <p>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. For more information, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/dev/storage-class-intro.html\">Storage Classes</a> in the\n   *             <i>Amazon S3 User Guide</i>.</p>\n   *          <note>\n   *             <ul>\n   *                <li>\n   *                   <p>For directory buckets, only the S3 Express One Zone storage class is supported to store newly created objects.</p>\n   *                </li>\n   *                <li>\n   *                   <p>Amazon S3 on Outposts only uses\n   *                the OUTPOSTS Storage Class.</p>\n   *                </li>\n   *             </ul>\n   *          </note>\n   */\n  StorageClass?: StorageClass;\n  /**\n   * <p>If the bucket is configured as a website, redirects requests for this object to another\n   *          object in the same bucket or to an external URL. Amazon S3 stores the value of this header in\n   *          the object metadata. For information about object metadata, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html\">Object Key and Metadata</a> in the <i>Amazon S3\n   *                User Guide</i>.</p>\n   *          <p>In the following example, the request header sets the redirect to an object\n   *          (anotherPage.html) in the same bucket:</p>\n   *          <p>\n   *             <code>x-amz-website-redirect-location: /anotherPage.html</code>\n   *          </p>\n   *          <p>In the following example, the request header sets the object redirect to another\n   *          website:</p>\n   *          <p>\n   *             <code>x-amz-website-redirect-location: http://www.example.com/</code>\n   *          </p>\n   *          <p>For more information about website hosting in Amazon S3, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/dev/WebsiteHosting.html\">Hosting Websites on Amazon S3</a> and\n   *             <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/dev/how-to-page-redirect.html\">How to\n   *                Configure Website Page Redirects</a> in the <i>Amazon S3\n   *                   User Guide</i>. </p>\n   *          <note>\n   *             <p>This functionality is not supported for directory buckets.</p>\n   *          </note>\n   */\n  WebsiteRedirectLocation?: string;\n  /**\n   * <p>Specifies the algorithm to use when encrypting the object (for example,\n   *          <code>AES256</code>).</p>\n   *          <note>\n   *             <p>This functionality is not supported for directory buckets.</p>\n   *          </note>\n   */\n  SSECustomerAlgorithm?: string;\n  /**\n   * <p>Specifies the customer-provided encryption key for Amazon S3 to use in encrypting data. This\n   *          value is used to store the object and then it is discarded; Amazon S3 does not store the\n   *          encryption key. The key must be appropriate for use with the algorithm specified in the\n   *             <code>x-amz-server-side-encryption-customer-algorithm</code> header.</p>\n   *          <note>\n   *             <p>This functionality is not supported for directory buckets.</p>\n   *          </note>\n   */\n  SSECustomerKey?: string;\n  /**\n   * <p>Specifies the 128-bit MD5 digest of the encryption key according to RFC 1321. Amazon S3 uses\n   *          this header for a message integrity check to ensure that the encryption key was transmitted\n   *          without error.</p>\n   *          <note>\n   *             <p>This functionality is not supported for directory buckets.</p>\n   *          </note>\n   */\n  SSECustomerKeyMD5?: string;\n  /**\n   * <p>If <code>x-amz-server-side-encryption</code> has a valid value of <code>aws:kms</code>\n   *          or <code>aws:kms:dsse</code>, this header specifies the ID (Key ID, Key ARN, or Key Alias) of the Key Management Service (KMS)\n   *          symmetric encryption customer managed key that was used for the object. If you specify\n   *             <code>x-amz-server-side-encryption:aws:kms</code> or\n   *             <code>x-amz-server-side-encryption:aws:kms:dsse</code>, but do not provide<code>\n   *             x-amz-server-side-encryption-aws-kms-key-id</code>, Amazon S3 uses the Amazon Web Services managed key\n   *             (<code>aws/s3</code>) to protect the data. If the KMS key does not exist in the same\n   *          account that's issuing the command, you must use the full ARN and not just the ID. </p>\n   *          <note>\n   *             <p>This functionality is not supported for directory buckets.</p>\n   *          </note>\n   */\n  SSEKMSKeyId?: string;\n  /**\n   * <p>Specifies the Amazon Web Services KMS Encryption Context to use for object encryption. The value of\n   *          this header is a base64-encoded UTF-8 string holding JSON with the encryption context\n   *          key-value pairs. This value is stored as object metadata and automatically gets passed on\n   *          to Amazon Web Services KMS for future <code>GetObject</code> or <code>CopyObject</code> operations on\n   *          this object. This value must be explicitly added during <code>CopyObject</code> operations.</p>\n   *          <note>\n   *             <p>This functionality is not supported for directory buckets.</p>\n   *          </note>\n   */\n  SSEKMSEncryptionContext?: string;\n  /**\n   * <p>Specifies whether Amazon S3 should use an S3 Bucket Key for object encryption with\n   *          server-side encryption using Key Management Service (KMS) keys (SSE-KMS). Setting this header to\n   *             <code>true</code> causes Amazon S3 to use an S3 Bucket Key for object encryption with\n   *          SSE-KMS.</p>\n   *          <p>Specifying this header with a PUT action doesn’t affect bucket-level settings for S3\n   *          Bucket Key.</p>\n   *          <note>\n   *             <p>This functionality is not supported for directory buckets.</p>\n   *          </note>\n   */\n  BucketKeyEnabled?: boolean;\n  /**\n   * <p>Confirms that the requester knows that they will be charged for the request. Bucket\n   *          owners need not specify this parameter in their requests. If either the source or\n   *          destination S3 bucket has Requester Pays enabled, the requester will pay for\n   *          corresponding charges to copy the object. For information about downloading objects from\n   *          Requester Pays buckets, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectsinRequesterPaysBuckets.html\">Downloading Objects in\n   *             Requester Pays Buckets</a> in the <i>Amazon S3 User Guide</i>.</p>\n   *          <note>\n   *             <p>This functionality is not supported for directory buckets.</p>\n   *          </note>\n   */\n  RequestPayer?: RequestPayer;\n  /**\n   * <p>The tag-set for the object. The tag-set must be encoded as URL Query parameters. (For\n   *          example, \"Key1=Value1\")</p>\n   *          <note>\n   *             <p>This functionality is not supported for directory buckets.</p>\n   *          </note>\n   */\n  Tagging?: string;\n  /**\n   * <p>The Object Lock mode that you want to apply to this object.</p>\n   *          <note>\n   *             <p>This functionality is not supported for directory buckets.</p>\n   *          </note>\n   */\n  ObjectLockMode?: ObjectLockMode;\n  /**\n   * <p>The date and time when you want this object's Object Lock to expire. Must be formatted\n   *          as a timestamp parameter.</p>\n   *          <note>\n   *             <p>This functionality is not supported for directory buckets.</p>\n   *          </note>\n   */\n  ObjectLockRetainUntilDate?: Date;\n  /**\n   * <p>Specifies whether a legal hold will be applied to this object. For more information\n   *          about S3 Object Lock, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/dev/object-lock.html\">Object Lock</a> in the <i>Amazon S3 User Guide</i>.</p>\n   *          <note>\n   *             <p>This functionality is not supported for directory buckets.</p>\n   *          </note>\n   */\n  ObjectLockLegalHoldStatus?: ObjectLockLegalHoldStatus;\n  /**\n   * <p>The account ID of the expected bucket owner. If the account ID that you provide does not match the actual owner of the bucket, the request fails with the HTTP status code <code>403 Forbidden</code> (access denied).</p>\n   */\n  ExpectedBucketOwner?: string;\n}\n\nexport type NodeJsRuntimeStreamingBlobPayloadInputTypes = string | Uint8Array | Buffer | Readable;\n\nexport interface PutObjectCommandInput extends Omit<PutObjectRequest, 'Body'> {\n  Body?: NodeJsRuntimeStreamingBlobPayloadInputTypes;\n}\n\nexport interface CompleteMultipartUploadOutput {\n  /**\n   * <p>The URI that identifies the newly created object.</p>\n   */\n  Location?: string;\n  /**\n   * <p>The name of the bucket that contains the newly created object. Does not return the access point\n   *          ARN or access point alias if used.</p>\n   *          <note>\n   *             <p>Access points are not supported by directory buckets.</p>\n   *          </note>\n   */\n  Bucket?: string;\n  /**\n   * <p>The object key of the newly created object.</p>\n   */\n  Key?: string;\n  /**\n   * <p>If the object expiration is configured, this will contain the expiration date\n   *             (<code>expiry-date</code>) and rule ID (<code>rule-id</code>). The value of\n   *             <code>rule-id</code> is URL-encoded.</p>\n   *          <note>\n   *             <p>This functionality is not supported for directory buckets.</p>\n   *          </note>\n   */\n  Expiration?: string;\n  /**\n   * <p>Entity tag that identifies the newly created object's data. Objects with different\n   *          object data will have different entity tags. The entity tag is an opaque string. The entity\n   *          tag may or may not be an MD5 digest of the object data. If the entity tag is not an MD5\n   *          digest of the object data, it will contain one or more nonhexadecimal characters and/or\n   *          will consist of less than 32 or more than 32 hexadecimal digits. For more information about\n   *          how the entity tag is calculated, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html\">Checking object\n   *             integrity</a> in the <i>Amazon S3 User Guide</i>.</p>\n   */\n  ETag?: string;\n  /**\n   * <p>The base64-encoded, 32-bit CRC32 checksum of the object. This will only be present if it was uploaded\n   *     with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated\n   *     with multipart uploads, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums\">\n   *     Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>\n   */\n  ChecksumCRC32?: string;\n  /**\n   * <p>The base64-encoded, 32-bit CRC32C checksum of the object. This will only be present if it was uploaded\n   *     with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated\n   *     with multipart uploads, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums\">\n   *     Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>\n   */\n  ChecksumCRC32C?: string;\n  /**\n   * <p>The base64-encoded, 160-bit SHA-1 digest of the object. This will only be present if it was uploaded\n   *     with the object. When you use the API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated\n   *     with multipart uploads, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums\">\n   *     Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>\n   */\n  ChecksumSHA1?: string;\n  /**\n   * <p>The base64-encoded, 256-bit SHA-256 digest of the object. This will only be present if it was uploaded\n   *     with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated\n   *     with multipart uploads, see <a href=\"https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums\">\n   *     Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>\n   */\n  ChecksumSHA256?: string;\n  /**\n   * <p>The server-side encryption algorithm used when storing this object in Amazon S3 (for example,\n   *             <code>AES256</code>, <code>aws:kms</code>).</p>\n   *          <note>\n   *             <p>For directory buckets, only server-side encryption with Amazon S3 managed keys (SSE-S3) (<code>AES256</code>) is supported.</p>\n   *          </note>\n   */\n  ServerSideEncryption?: ServerSideEncryption;\n  /**\n   * <p>Version ID of the newly created object, in case the bucket has versioning turned\n   *          on.</p>\n   *          <note>\n   *             <p>This functionality is not supported for directory buckets.</p>\n   *          </note>\n   */\n  VersionId?: string;\n  /**\n   * <p>If present, indicates the ID of the Key Management Service (KMS) symmetric encryption customer managed key\n   *          that was used for the object.</p>\n   *          <note>\n   *             <p>This functionality is not supported for directory buckets.</p>\n   *          </note>\n   */\n  SSEKMSKeyId?: string;\n  /**\n   * <p>Indicates whether the multipart upload uses an S3 Bucket Key for server-side encryption\n   *          with Key Management Service (KMS) keys (SSE-KMS).</p>\n   *          <note>\n   *             <p>This functionality is not supported for directory buckets.</p>\n   *          </note>\n   */\n  BucketKeyEnabled?: boolean;\n  /**\n   * <p>If present, indicates that the requester was successfully charged for the\n   *          request.</p>\n   *          <note>\n   *             <p>This functionality is not supported for directory buckets.</p>\n   *          </note>\n   */\n  RequestCharged?: RequestCharged;\n}\n\nexport interface CompleteMultipartUploadCommandOutput\n  extends CompleteMultipartUploadOutput,\n  MetadataBearer {}\n\nexport interface ImageIdentifier {\n  /**\n   * <p>The <code>sha256</code> digest of the image manifest.</p>\n   */\n  imageDigest?: string;\n  /**\n   * <p>The tag used for the image.</p>\n   */\n  imageTag?: string;\n}\n\nexport interface DescribeImagesFilter {\n  /**\n   * <p>The tag status with which to filter your <a>DescribeImages</a> results. You\n   *             can filter results based on whether they are <code>TAGGED</code> or\n   *                 <code>UNTAGGED</code>.</p>\n   */\n  tagStatus?: TagStatus;\n}\n\nexport const TagStatus = {\n  ANY: 'ANY',\n  TAGGED: 'TAGGED',\n  UNTAGGED: 'UNTAGGED',\n} as const;\n\nexport type TagStatus = (typeof TagStatus)[keyof typeof TagStatus];\n\nexport interface DescribeImagesRequest {\n  /**\n   * <p>The Amazon Web Services account ID associated with the registry that contains the repository in\n   *             which to describe images. If you do not specify a registry, the default registry is assumed.</p>\n   */\n  registryId?: string;\n  /**\n   * <p>The repository that contains the images to describe.</p>\n   */\n  repositoryName: string | undefined;\n  /**\n   * <p>The list of image IDs for the requested repository.</p>\n   */\n  imageIds?: ImageIdentifier[];\n  /**\n   * <p>The <code>nextToken</code> value returned from a previous paginated\n   *                 <code>DescribeImages</code> request where <code>maxResults</code> was used and the\n   *             results exceeded the value of that parameter. Pagination continues from the end of the\n   *             previous results that returned the <code>nextToken</code> value. This value is\n   *                 <code>null</code> when there are no more results to return. This option cannot be\n   *             used when you specify images with <code>imageIds</code>.</p>\n   */\n  nextToken?: string;\n  /**\n   * <p>The maximum number of repository results returned by <code>DescribeImages</code> in\n   *             paginated output. When this parameter is used, <code>DescribeImages</code> only returns\n   *                 <code>maxResults</code> results in a single page along with a <code>nextToken</code>\n   *             response element. The remaining results of the initial request can be seen by sending\n   *             another <code>DescribeImages</code> request with the returned <code>nextToken</code>\n   *             value. This value can be between 1 and 1000. If this\n   *             parameter is not used, then <code>DescribeImages</code> returns up to\n   *             100 results and a <code>nextToken</code> value, if applicable. This\n   *             option cannot be used when you specify images with <code>imageIds</code>.</p>\n   */\n  maxResults?: number;\n  /**\n   * <p>The filter key and value with which to filter your <code>DescribeImages</code>\n   *             results.</p>\n   */\n  filter?: DescribeImagesFilter;\n}\n\nexport interface DescribeImagesCommandInput extends DescribeImagesRequest {}\n\nexport interface DescribeImagesCommandOutput extends DescribeImagesResponse, MetadataBearer {}\n\nexport const ScanStatus = {\n  ACTIVE: 'ACTIVE',\n  COMPLETE: 'COMPLETE',\n  FAILED: 'FAILED',\n  FINDINGS_UNAVAILABLE: 'FINDINGS_UNAVAILABLE',\n  IN_PROGRESS: 'IN_PROGRESS',\n  PENDING: 'PENDING',\n  SCAN_ELIGIBILITY_EXPIRED: 'SCAN_ELIGIBILITY_EXPIRED',\n  UNSUPPORTED_IMAGE: 'UNSUPPORTED_IMAGE',\n} as const;\n\nexport type ScanStatus = (typeof ScanStatus)[keyof typeof ScanStatus];\n\nexport const FindingSeverity = {\n  CRITICAL: 'CRITICAL',\n  HIGH: 'HIGH',\n  INFORMATIONAL: 'INFORMATIONAL',\n  LOW: 'LOW',\n  MEDIUM: 'MEDIUM',\n  UNDEFINED: 'UNDEFINED',\n} as const;\n\n/**\n */\nexport type FindingSeverity = (typeof FindingSeverity)[keyof typeof FindingSeverity];\n\nexport interface ImageScanStatus {\n  /**\n   * <p>The current state of an image scan.</p>\n   */\n  status?: ScanStatus;\n  /**\n   * <p>The description of the image scan status.</p>\n   */\n  description?: string;\n}\n\nexport interface ImageScanFindingsSummary {\n  /**\n   * <p>The time of the last completed image scan.</p>\n   */\n  imageScanCompletedAt?: Date;\n  /**\n   * <p>The time when the vulnerability data was last scanned.</p>\n   */\n  vulnerabilitySourceUpdatedAt?: Date;\n  /**\n   * <p>The image vulnerability counts, sorted by severity.</p>\n   */\n  findingSeverityCounts?: Partial<Record<FindingSeverity, number>>;\n}\n\nexport interface ImageDetail {\n  /**\n   * <p>The Amazon Web Services account ID associated with the registry to which this image belongs.</p>\n   */\n  registryId?: string;\n  /**\n   * <p>The name of the repository to which this image belongs.</p>\n   */\n  repositoryName?: string;\n  /**\n   * <p>The <code>sha256</code> digest of the image manifest.</p>\n   */\n  imageDigest?: string;\n  /**\n   * <p>The list of tags associated with this image.</p>\n   */\n  imageTags?: string[];\n  /**\n   * <p>The size, in bytes, of the image in the repository.</p>\n   *          <p>If the image is a manifest list, this will be the max size of all manifests in the\n   *             list.</p>\n   *          <note>\n   *             <p>Beginning with Docker version 1.9, the Docker client compresses image layers\n   *                 before pushing them to a V2 Docker registry. The output of the <code>docker\n   *                     images</code> command shows the uncompressed image size, so it may return a\n   *                 larger image size than the image sizes returned by <a>DescribeImages</a>.</p>\n   *          </note>\n   */\n  imageSizeInBytes?: number;\n  /**\n   * <p>The date and time, expressed in standard JavaScript date format, at which the current\n   *             image was pushed to the repository. </p>\n   */\n  imagePushedAt?: Date;\n  /**\n   * <p>The current state of the scan.</p>\n   */\n  imageScanStatus?: ImageScanStatus;\n  /**\n   * <p>A summary of the last completed image scan.</p>\n   */\n  imageScanFindingsSummary?: ImageScanFindingsSummary;\n  /**\n   * <p>The media type of the image manifest.</p>\n   */\n  imageManifestMediaType?: string;\n  /**\n   * <p>The artifact media type of the image.</p>\n   */\n  artifactMediaType?: string;\n  /**\n   * <p>The date and time, expressed in standard JavaScript date format, when Amazon ECR recorded\n   *             the last image pull.</p>\n   *          <note>\n   *             <p>Amazon ECR refreshes the last image pull timestamp at least once every 24 hours. For\n   *                 example, if you pull an image once a day then the <code>lastRecordedPullTime</code>\n   *                 timestamp will indicate the exact time that the image was last pulled. However, if\n   *                 you pull an image once an hour, because Amazon ECR refreshes the\n   *                     <code>lastRecordedPullTime</code> timestamp at least once every 24 hours, the\n   *                 result may not be the exact time that the image was last pulled.</p>\n   *          </note>\n   */\n  lastRecordedPullTime?: Date;\n}\n\nexport interface DescribeImagesResponse {\n  /**\n   * <p>A list of <a>ImageDetail</a> objects that contain data about the\n   *             image.</p>\n   */\n  imageDetails?: ImageDetail[];\n  /**\n   * <p>The <code>nextToken</code> value to include in a future <code>DescribeImages</code>\n   *             request. When the results of a <code>DescribeImages</code> request exceed\n   *                 <code>maxResults</code>, this value can be used to retrieve the next page of\n   *             results. This value is <code>null</code> when there are no more results to\n   *             return.</p>\n   */\n  nextToken?: string;\n}\n\nexport interface DescribeRepositoriesRequest {\n  /**\n   * <p>The Amazon Web Services account ID associated with the registry that contains the repositories to be\n   *             described. If you do not specify a registry, the default registry is assumed.</p>\n   */\n  registryId?: string;\n  /**\n   * <p>A list of repositories to describe. If this parameter is omitted, then all\n   *             repositories in a registry are described.</p>\n   */\n  repositoryNames?: string[];\n  /**\n   * <p>The <code>nextToken</code> value returned from a previous paginated\n   *                 <code>DescribeRepositories</code> request where <code>maxResults</code> was used and\n   *             the results exceeded the value of that parameter. Pagination continues from the end of\n   *             the previous results that returned the <code>nextToken</code> value. This value is\n   *                 <code>null</code> when there are no more results to return. This option cannot be\n   *             used when you specify repositories with <code>repositoryNames</code>.</p>\n   *          <note>\n   *             <p>This token should be treated as an opaque identifier that is only used to\n   *                 retrieve the next items in a list and not for other programmatic purposes.</p>\n   *          </note>\n   */\n  nextToken?: string;\n  /**\n   * <p>The maximum number of repository results returned by <code>DescribeRepositories</code>\n   *             in paginated output. When this parameter is used, <code>DescribeRepositories</code> only\n   *             returns <code>maxResults</code> results in a single page along with a\n   *                 <code>nextToken</code> response element. The remaining results of the initial\n   *             request can be seen by sending another <code>DescribeRepositories</code> request with\n   *             the returned <code>nextToken</code> value. This value can be between 1\n   *             and 1000. If this parameter is not used, then\n   *                 <code>DescribeRepositories</code> returns up to 100 results and a\n   *                 <code>nextToken</code> value, if applicable. This option cannot be used when you\n   *             specify repositories with <code>repositoryNames</code>.</p>\n   */\n  maxResults?: number;\n}\n\nexport interface DescribeRepositoriesCommandInput extends DescribeRepositoriesRequest {}\n\nexport const ImageTagMutability = {\n  IMMUTABLE: 'IMMUTABLE',\n  MUTABLE: 'MUTABLE',\n} as const;\n\n/**\n */\nexport type ImageTagMutability = (typeof ImageTagMutability)[keyof typeof ImageTagMutability];\n\nexport interface ImageScanningConfiguration {\n  /**\n   * <p>The setting that determines whether images are scanned after being pushed to a\n   *             repository. If set to <code>true</code>, images will be scanned after being pushed. If\n   *             this parameter is not specified, it will default to <code>false</code> and images will\n   *             not be scanned unless a scan is manually started with the <a href=\"https://docs.aws.amazon.com/AmazonECR/latest/APIReference/API_StartImageScan.html\">API_StartImageScan</a> API.</p>\n   */\n  scanOnPush?: boolean;\n}\n\nexport const EncryptionType = {\n  AES256: 'AES256',\n  KMS: 'KMS',\n  KMS_DSSE: 'KMS_DSSE',\n} as const;\n\n/**\n */\nexport type EncryptionType = (typeof EncryptionType)[keyof typeof EncryptionType];\n\nexport interface EncryptionConfiguration {\n  /**\n   * <p>The encryption type to use.</p>\n   *          <p>If you use the <code>KMS</code> encryption type, the contents of the repository will\n   *             be encrypted using server-side encryption with Key Management Service key stored in KMS. When you\n   *             use KMS to encrypt your data, you can either use the default Amazon Web Services managed KMS key\n   *             for Amazon ECR, or specify your own KMS key, which you already created.</p>\n   *          <p>If you use the <code>KMS_DSSE</code> encryption type, the contents of the repository\n   *             will be encrypted with two layers of encryption using server-side encryption with the\n   *             KMS Management Service key stored in KMS. Similar to the <code>KMS</code> encryption type, you\n   *             can either use the default Amazon Web Services managed KMS key for Amazon ECR, or specify your own KMS\n   *             key, which you've already created. </p>\n   *          <p>If you use the <code>AES256</code> encryption type, Amazon ECR uses server-side encryption\n   *             with Amazon S3-managed encryption keys which encrypts the images in the repository using an\n   *             AES256 encryption algorithm.</p>\n   *          <p>For more information, see <a href=\"https://docs.aws.amazon.com/AmazonECR/latest/userguide/encryption-at-rest.html\">Amazon ECR encryption at\n   *             rest</a> in the <i>Amazon Elastic Container Registry User Guide</i>.</p>\n   */\n  encryptionType: EncryptionType | undefined;\n\n  /**\n   * <p>If you use the <code>KMS</code> encryption type, specify the KMS key to use for\n   *             encryption. The alias, key ID, or full ARN of the KMS key can be specified. The key\n   *             must exist in the same Region as the repository. If no key is specified, the default\n   *             Amazon Web Services managed KMS key for Amazon ECR will be used.</p>\n   */\n  kmsKey?: string;\n}\n\nexport interface Repository {\n  /**\n   * <p>The Amazon Resource Name (ARN) that identifies the repository. The ARN contains the <code>arn:aws:ecr</code> namespace, followed by the region of the\n   *     repository, Amazon Web Services account ID of the repository owner, repository namespace, and repository name.\n   *     For example, <code>arn:aws:ecr:region:012345678910:repository-namespace/repository-name</code>.</p>\n   */\n  repositoryArn?: string;\n\n  /**\n   * <p>The Amazon Web Services account ID associated with the registry that contains the repository.</p>\n   */\n  registryId?: string;\n\n  /**\n   * <p>The name of the repository.</p>\n   */\n  repositoryName?: string;\n\n  /**\n   * <p>The URI for the repository. You can use this URI for container image <code>push</code>\n   *             and <code>pull</code> operations.</p>\n   */\n  repositoryUri?: string;\n\n  /**\n   * <p>The date and time, in JavaScript date format, when the repository was created.</p>\n   */\n  createdAt?: Date;\n\n  /**\n   * <p>The tag mutability setting for the repository.</p>\n   */\n  imageTagMutability?: ImageTagMutability;\n\n  /**\n   * <p>The image scanning configuration for a repository.</p>\n   */\n  imageScanningConfiguration?: ImageScanningConfiguration;\n\n  /**\n   * <p>The encryption configuration for the repository. This determines how the contents of\n   *             your repository are encrypted at rest.</p>\n   */\n  encryptionConfiguration?: EncryptionConfiguration;\n}\n\nexport interface DescribeRepositoriesResponse {\n  /**\n   * <p>A list of repository objects corresponding to valid repositories.</p>\n   */\n  repositories?: Repository[];\n  /**\n   * <p>The <code>nextToken</code> value to include in a future\n   *                 <code>DescribeRepositories</code> request. When the results of a\n   *                 <code>DescribeRepositories</code> request exceed <code>maxResults</code>, this value\n   *             can be used to retrieve the next page of results. This value is <code>null</code> when\n   *             there are no more results to return.</p>\n   */\n  nextToken?: string;\n}\n\nexport interface DescribeRepositoriesCommandOutput\n  extends DescribeRepositoriesResponse,\n  MetadataBearer {}\n\nexport interface GetAuthorizationTokenRequest {\n  /**\n   * @deprecated\n   *\n   * <p>A list of Amazon Web Services account IDs that are associated with the registries for which to get\n   *             AuthorizationData objects. If you do not specify a registry, the default registry is assumed.</p>\n   */\n  registryIds?: string[];\n}\n\nexport interface GetAuthorizationTokenCommandInput extends GetAuthorizationTokenRequest {}\n\nexport interface AuthorizationData {\n  /**\n   * <p>A base64-encoded string that contains authorization data for the specified Amazon ECR\n   *             registry. When the string is decoded, it is presented in the format\n   *                 <code>user:password</code> for private registry authentication using <code>docker\n   *                 login</code>.</p>\n   */\n  authorizationToken?: string;\n  /**\n   * <p>The Unix time in seconds and milliseconds when the authorization token expires.\n   *             Authorization tokens are valid for 12 hours.</p>\n   */\n  expiresAt?: Date;\n  /**\n   * <p>The registry URL to use for this authorization token in a <code>docker login</code>\n   *             command. The Amazon ECR registry URL format is\n   *         <code>https://aws_account_id.dkr.ecr.region.amazonaws.com</code>. For example,\n   *         <code>https://012345678910.dkr.ecr.us-east-1.amazonaws.com</code>.. </p>\n   */\n  proxyEndpoint?: string;\n}\n\nexport interface GetAuthorizationTokenResponse {\n  /**\n   * <p>A list of authorization token data objects that correspond to the\n   *                 <code>registryIds</code> values in the request.</p>\n   */\n  authorizationData?: AuthorizationData[];\n}\n\nexport interface GetAuthorizationTokenCommandOutput\n  extends GetAuthorizationTokenResponse,\n  MetadataBearer {}\n\nexport interface GetSecretValueRequest {\n  /**\n   * <p>The ARN or name of the secret to retrieve. To retrieve a secret from another account, you must use an ARN.</p>\n   *          <p>For an ARN, we recommend that you specify a complete ARN rather\n   *       than a partial ARN. See <a href=\"https://docs.aws.amazon.com/secretsmanager/latest/userguide/troubleshoot.html#ARN_secretnamehyphen\">Finding a secret from a partial ARN</a>.</p>\n   */\n  SecretId: string | undefined;\n  /**\n   * <p>The unique identifier of the version of the secret to retrieve. If\n   *       you include both this parameter and <code>VersionStage</code>, the two parameters must refer\n   *       to the same secret version. If you don't specify either a <code>VersionStage</code> or\n   *         <code>VersionId</code>, then Secrets Manager returns the <code>AWSCURRENT</code> version.</p>\n   *          <p>This value is typically a <a href=\"https://wikipedia.org/wiki/Universally_unique_identifier\">UUID-type</a> value with\n   *       32 hexadecimal digits.</p>\n   */\n  VersionId?: string;\n  /**\n   * <p>The staging label of the version of the secret to retrieve. </p>\n   *          <p>Secrets Manager uses staging labels to keep track of different versions during the rotation process.\n   *       If you include both this parameter and <code>VersionId</code>, the two parameters must refer\n   *       to the same secret version. If you don't specify either a <code>VersionStage</code> or\n   *       <code>VersionId</code>, Secrets Manager returns the <code>AWSCURRENT</code> version.</p>\n   */\n  VersionStage?: string;\n}\n\nexport interface GetSecretValueCommandInput extends GetSecretValueRequest {}\n\nexport interface GetSecretValueResponse {\n  /**\n   * <p>The ARN of the secret.</p>\n   */\n  ARN?: string;\n  /**\n   * <p>The friendly name of the secret.</p>\n   */\n  Name?: string;\n  /**\n   * <p>The unique identifier of this version of the secret.</p>\n   */\n  VersionId?: string;\n  /**\n   * <p>The decrypted secret value, if the secret value was originally provided as\n   *       binary data in the form of a byte array. When you retrieve a <code>SecretBinary</code> using the HTTP API, the Python SDK, or the Amazon Web Services CLI, the value is Base64-encoded. Otherwise, it is not encoded.</p>\n   *          <p>If the secret was created by using the Secrets Manager console, or if the secret value was\n   *       originally provided as a string, then this field is omitted. The secret value appears in\n   *       <code>SecretString</code> instead.</p>\n   *          <p>Sensitive: This field contains sensitive information, so the service does not include it in CloudTrail log entries. If you create your own log entries, you must also avoid logging the information in this field.</p>\n   */\n  SecretBinary?: Uint8Array;\n  /**\n   * <p>The decrypted secret value, if the secret value was originally provided as a string or\n   *       through the Secrets Manager console.</p>\n   *          <p>If this secret was created by using the console, then Secrets Manager stores the information as a\n   *       JSON structure of key/value pairs. </p>\n   *          <p>Sensitive: This field contains sensitive information, so the service does not include it in CloudTrail log entries. If you create your own log entries, you must also avoid logging the information in this field.</p>\n   */\n  SecretString?: string;\n  /**\n   * <p>A list of all of the staging labels currently attached to this version of the\n   *       secret.</p>\n   */\n  VersionStages?: string[];\n  /**\n   * <p>The date and time that this version of the secret was created. If you don't specify\n   *       which version in <code>VersionId</code> or <code>VersionStage</code>, then Secrets Manager uses the\n   *       <code>AWSCURRENT</code> version.</p>\n   */\n  CreatedDate?: Date;\n}\n\nexport interface GetSecretValueCommandOutput extends GetSecretValueResponse, MetadataBearer {}\n"]}

package/lib/aws.d.ts

@@ -0,0 +1,70 @@
+import { AssumeRoleCommandInput } from '@aws-sdk/client-sts';
+import { CompleteMultipartUploadCommandOutput, DescribeImagesCommandInput, DescribeImagesCommandOutput, DescribeRepositoriesCommandInput, DescribeRepositoriesCommandOutput, GetAuthorizationTokenCommandInput, GetAuthorizationTokenCommandOutput, GetBucketEncryptionCommandInput, GetBucketEncryptionCommandOutput, GetBucketLocationCommandInput, GetBucketLocationCommandOutput, GetSecretValueCommandInput, GetSecretValueCommandOutput, ListObjectsV2CommandInput, ListObjectsV2CommandOutput, PutObjectCommandInput } from './aws-types';
+export type AssumeRoleAdditionalOptions = Partial<Omit<AssumeRoleCommandInput, 'ExternalId' | 'RoleArn'>>;
+export interface IS3Client {
+    getBucketEncryption(input: GetBucketEncryptionCommandInput): Promise<GetBucketEncryptionCommandOutput>;
+    getBucketLocation(input: GetBucketLocationCommandInput): Promise<GetBucketLocationCommandOutput>;
+    listObjectsV2(input: ListObjectsV2CommandInput): Promise<ListObjectsV2CommandOutput>;
+    upload(input: PutObjectCommandInput): Promise<CompleteMultipartUploadCommandOutput>;
+}
+export interface IECRClient {
+    describeImages(input: DescribeImagesCommandInput): Promise<DescribeImagesCommandOutput>;
+    describeRepositories(input: DescribeRepositoriesCommandInput): Promise<DescribeRepositoriesCommandOutput>;
+    getAuthorizationToken(input?: GetAuthorizationTokenCommandInput): Promise<GetAuthorizationTokenCommandOutput>;
+}
+export interface ISecretsManagerClient {
+    getSecretValue(input: GetSecretValueCommandInput): Promise<GetSecretValueCommandOutput>;
+}
+/**
+ * AWS SDK operations required by Asset Publishing
+ */
+export interface IAws {
+    discoverPartition(): Promise<string>;
+    discoverDefaultRegion(): Promise<string>;
+    discoverCurrentAccount(): Promise<Account>;
+    discoverTargetAccount(options: ClientOptions): Promise<Account>;
+    s3Client(options: ClientOptions): Promise<IS3Client>;
+    ecrClient(options: ClientOptions): Promise<IECRClient>;
+    secretsManagerClient(options: ClientOptions): Promise<ISecretsManagerClient>;
+}
+export interface ClientOptions {
+    region?: string;
+    assumeRoleArn?: string;
+    assumeRoleExternalId?: string;
+    assumeRoleAdditionalOptions?: AssumeRoleAdditionalOptions;
+    quiet?: boolean;
+}
+/**
+ * An AWS account
+ *
+ * An AWS account always exists in only one partition. Usually we don't care about
+ * the partition, but when we need to form ARNs we do.
+ */
+export interface Account {
+    /**
+     * The account number
+     */
+    readonly accountId: string;
+    /**
+     * The partition ('aws' or 'aws-cn' or otherwise)
+     */
+    readonly partition: string;
+}
+/**
+ * AWS client using the AWS SDK for JS with no special configuration
+ */
+export declare class DefaultAwsClient implements IAws {
+    private readonly profile?;
+    private account?;
+    private config;
+    constructor(profile?: string | undefined);
+    s3Client(options: ClientOptions): Promise<IS3Client>;
+    ecrClient(options: ClientOptions): Promise<IECRClient>;
+    secretsManagerClient(options: ClientOptions): Promise<ISecretsManagerClient>;
+    discoverPartition(): Promise<string>;
+    discoverDefaultRegion(): Promise<string>;
+    discoverCurrentAccount(): Promise<Account>;
+    discoverTargetAccount(options: ClientOptions): Promise<Account>;
+    private getAccount;
+    private awsOptions;
+}

package/lib/aws.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultAwsClient = void 0;
+const os = require("os");
+const client_ecr_1 = require("@aws-sdk/client-ecr");
+const client_s3_1 = require("@aws-sdk/client-s3");
+const client_secrets_manager_1 = require("@aws-sdk/client-secrets-manager");
+const client_sts_1 = require("@aws-sdk/client-sts");
+const credential_providers_1 = require("@aws-sdk/credential-providers");
+const lib_storage_1 = require("@aws-sdk/lib-storage");
+const config_resolver_1 = require("@smithy/config-resolver");
+const node_config_provider_1 = require("@smithy/node-config-provider");
+const USER_AGENT = 'cdk-assets';
+/**
+ * AWS client using the AWS SDK for JS with no special configuration
+ */
+class DefaultAwsClient {
+    constructor(profile) {
+        this.profile = profile;
+        const clientConfig = {
+            customUserAgent: USER_AGENT,
+        };
+        this.config = {
+            clientConfig,
+            credentials: (0, credential_providers_1.fromNodeProviderChain)({
+                profile: this.profile,
+                clientConfig,
+            }),
+        };
+    }
+    async s3Client(options) {
+        const client = new client_s3_1.S3Client(await this.awsOptions(options));
+        return {
+            getBucketEncryption: (input) => client.send(new client_s3_1.GetBucketEncryptionCommand(input)),
+            getBucketLocation: (input) => client.send(new client_s3_1.GetBucketLocationCommand(input)),
+            listObjectsV2: (input) => client.send(new client_s3_1.ListObjectsV2Command(input)),
+            upload: (input) => {
+                const upload = new lib_storage_1.Upload({
+                    client,
+                    params: input,
+                });
+                return upload.done();
+            },
+        };
+    }
+    async ecrClient(options) {
+        const client = new client_ecr_1.ECRClient(await this.awsOptions(options));
+        return {
+            describeImages: (input) => client.send(new client_ecr_1.DescribeImagesCommand(input)),
+            describeRepositories: (input) => client.send(new client_ecr_1.DescribeRepositoriesCommand(input)),
+            getAuthorizationToken: (input) => client.send(new client_ecr_1.GetAuthorizationTokenCommand(input ?? {})),
+        };
+    }
+    async secretsManagerClient(options) {
+        const client = new client_secrets_manager_1.SecretsManagerClient(await this.awsOptions(options));
+        return {
+            getSecretValue: (input) => client.send(new client_secrets_manager_1.GetSecretValueCommand(input)),
+        };
+    }
+    async discoverPartition() {
+        return (await this.discoverCurrentAccount()).partition;
+    }
+    async discoverDefaultRegion() {
+        return (0, node_config_provider_1.loadConfig)(config_resolver_1.NODE_REGION_CONFIG_OPTIONS, config_resolver_1.NODE_REGION_CONFIG_FILE_OPTIONS)() || 'us-east-1';
+    }
+    async discoverCurrentAccount() {
+        if (this.account === undefined) {
+            this.account = await this.getAccount();
+        }
+        return this.account;
+    }
+    async discoverTargetAccount(options) {
+        return this.getAccount(await this.awsOptions(options));
+    }
+    async getAccount(options) {
+        this.config.clientConfig = options ?? this.config.clientConfig;
+        const stsClient = new client_sts_1.STSClient(await this.awsOptions(options));
+        const command = new client_sts_1.GetCallerIdentityCommand();
+        const response = await stsClient.send(command);
+        if (!response.Account || !response.Arn) {
+            throw new Error(`Unrecognized response from STS: '${JSON.stringify(response)}'`);
+        }
+        return {
+            accountId: response.Account,
+            partition: response.Arn.split(':')[1],
+        };
+    }
+    async awsOptions(options) {
+        const config = this.config;
+        config.region = options?.region;
+        if (options) {
+            config.region = options.region;
+            if (options.assumeRoleArn) {
+                config.credentials = (0, credential_providers_1.fromTemporaryCredentials)({
+                    params: {
+                        RoleArn: options.assumeRoleArn,
+                        ExternalId: options.assumeRoleExternalId,
+                        RoleSessionName: `${USER_AGENT}-${safeUsername()}`,
+                        TransitiveTagKeys: options.assumeRoleAdditionalOptions?.Tags
+                            ? options.assumeRoleAdditionalOptions.Tags.map((t) => t.Key)
+                            : undefined,
+                        ...options.assumeRoleAdditionalOptions,
+                    },
+                    clientConfig: this.config.clientConfig,
+                });
+            }
+        }
+        return config;
+    }
+}
+exports.DefaultAwsClient = DefaultAwsClient;
+/**
+ * Return the username with characters invalid for a RoleSessionName removed
+ *
+ * @see https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html#API_AssumeRole_RequestParameters
+ */
+function safeUsername() {
+    try {
+        return os.userInfo().username.replace(/[^\w+=,.@-]/g, '@');
+    }
+    catch {
+        return 'noname';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws.js","sourceRoot":"","sources":["aws.ts"],"names":[],"mappings":"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","sourcesContent":["import * as os from 'os';\nimport {\n  DescribeImagesCommand,\n  DescribeRepositoriesCommand,\n  ECRClient,\n  GetAuthorizationTokenCommand,\n} from '@aws-sdk/client-ecr';\nimport {\n  GetBucketEncryptionCommand,\n  GetBucketLocationCommand,\n  ListObjectsV2Command,\n  S3Client,\n} from '@aws-sdk/client-s3';\nimport { GetSecretValueCommand, SecretsManagerClient } from '@aws-sdk/client-secrets-manager';\nimport {\n  AssumeRoleCommandInput,\n  GetCallerIdentityCommand,\n  STSClient,\n  STSClientConfig,\n} from '@aws-sdk/client-sts';\nimport { fromNodeProviderChain, fromTemporaryCredentials } from '@aws-sdk/credential-providers';\nimport { Upload } from '@aws-sdk/lib-storage';\nimport {\n  NODE_REGION_CONFIG_FILE_OPTIONS,\n  NODE_REGION_CONFIG_OPTIONS,\n} from '@smithy/config-resolver';\nimport { loadConfig } from '@smithy/node-config-provider';\nimport {\n  AwsCredentialIdentityProvider,\n  CompleteMultipartUploadCommandOutput,\n  DescribeImagesCommandInput,\n  DescribeImagesCommandOutput,\n  DescribeRepositoriesCommandInput,\n  DescribeRepositoriesCommandOutput,\n  GetAuthorizationTokenCommandInput,\n  GetAuthorizationTokenCommandOutput,\n  GetBucketEncryptionCommandInput,\n  GetBucketEncryptionCommandOutput,\n  GetBucketLocationCommandInput,\n  GetBucketLocationCommandOutput,\n  GetSecretValueCommandInput,\n  GetSecretValueCommandOutput,\n  ListObjectsV2CommandInput,\n  ListObjectsV2CommandOutput,\n  PutObjectCommandInput,\n} from './aws-types';\n\nexport type AssumeRoleAdditionalOptions = Partial<\n  Omit<AssumeRoleCommandInput, 'ExternalId' | 'RoleArn'>\n>;\n\nexport interface IS3Client {\n  getBucketEncryption(\n    input: GetBucketEncryptionCommandInput\n  ): Promise<GetBucketEncryptionCommandOutput>;\n  getBucketLocation(input: GetBucketLocationCommandInput): Promise<GetBucketLocationCommandOutput>;\n  listObjectsV2(input: ListObjectsV2CommandInput): Promise<ListObjectsV2CommandOutput>;\n  upload(input: PutObjectCommandInput): Promise<CompleteMultipartUploadCommandOutput>;\n}\n\nexport interface IECRClient {\n  describeImages(input: DescribeImagesCommandInput): Promise<DescribeImagesCommandOutput>;\n  describeRepositories(\n    input: DescribeRepositoriesCommandInput\n  ): Promise<DescribeRepositoriesCommandOutput>;\n  getAuthorizationToken(\n    input?: GetAuthorizationTokenCommandInput\n  ): Promise<GetAuthorizationTokenCommandOutput>;\n}\n\nexport interface ISecretsManagerClient {\n  getSecretValue(input: GetSecretValueCommandInput): Promise<GetSecretValueCommandOutput>;\n}\n\n/**\n * AWS SDK operations required by Asset Publishing\n */\nexport interface IAws {\n  discoverPartition(): Promise<string>;\n  discoverDefaultRegion(): Promise<string>;\n  discoverCurrentAccount(): Promise<Account>;\n\n  discoverTargetAccount(options: ClientOptions): Promise<Account>;\n  s3Client(options: ClientOptions): Promise<IS3Client>;\n  ecrClient(options: ClientOptions): Promise<IECRClient>;\n  secretsManagerClient(options: ClientOptions): Promise<ISecretsManagerClient>;\n}\n\nexport interface ClientOptions {\n  region?: string;\n  assumeRoleArn?: string;\n  assumeRoleExternalId?: string;\n  assumeRoleAdditionalOptions?: AssumeRoleAdditionalOptions;\n  quiet?: boolean;\n}\n\nconst USER_AGENT = 'cdk-assets';\n\ninterface Configuration {\n  clientConfig: STSClientConfig;\n  region?: string;\n  credentials: AwsCredentialIdentityProvider;\n}\n\n/**\n * An AWS account\n *\n * An AWS account always exists in only one partition. Usually we don't care about\n * the partition, but when we need to form ARNs we do.\n */\nexport interface Account {\n  /**\n   * The account number\n   */\n  readonly accountId: string;\n\n  /**\n   * The partition ('aws' or 'aws-cn' or otherwise)\n   */\n  readonly partition: string;\n}\n\n/**\n * AWS client using the AWS SDK for JS with no special configuration\n */\nexport class DefaultAwsClient implements IAws {\n  private account?: Account;\n  private config: Configuration;\n\n  constructor(private readonly profile?: string) {\n    const clientConfig: STSClientConfig = {\n      customUserAgent: USER_AGENT,\n    };\n    this.config = {\n      clientConfig,\n      credentials: fromNodeProviderChain({\n        profile: this.profile,\n        clientConfig,\n      }),\n    };\n  }\n\n  public async s3Client(options: ClientOptions): Promise<IS3Client> {\n    const client = new S3Client(await this.awsOptions(options));\n    return {\n      getBucketEncryption: (\n        input: GetBucketEncryptionCommandInput,\n      ): Promise<GetBucketEncryptionCommandOutput> =>\n        client.send(new GetBucketEncryptionCommand(input)),\n      getBucketLocation: (\n        input: GetBucketLocationCommandInput,\n      ): Promise<GetBucketLocationCommandOutput> =>\n        client.send(new GetBucketLocationCommand(input)),\n      listObjectsV2: (input: ListObjectsV2CommandInput): Promise<ListObjectsV2CommandOutput> =>\n        client.send(new ListObjectsV2Command(input)),\n      upload: (input: PutObjectCommandInput): Promise<CompleteMultipartUploadCommandOutput> => {\n        const upload = new Upload({\n          client,\n          params: input,\n        });\n        return upload.done();\n      },\n    };\n  }\n\n  public async ecrClient(options: ClientOptions): Promise<IECRClient> {\n    const client = new ECRClient(await this.awsOptions(options));\n    return {\n      describeImages: (input: DescribeImagesCommandInput): Promise<DescribeImagesCommandOutput> =>\n        client.send(new DescribeImagesCommand(input)),\n      describeRepositories: (\n        input: DescribeRepositoriesCommandInput,\n      ): Promise<DescribeRepositoriesCommandOutput> =>\n        client.send(new DescribeRepositoriesCommand(input)),\n      getAuthorizationToken: (\n        input: GetAuthorizationTokenCommandInput,\n      ): Promise<GetAuthorizationTokenCommandOutput> =>\n        client.send(new GetAuthorizationTokenCommand(input ?? {})),\n    };\n  }\n\n  public async secretsManagerClient(options: ClientOptions): Promise<ISecretsManagerClient> {\n    const client = new SecretsManagerClient(await this.awsOptions(options));\n    return {\n      getSecretValue: (input: GetSecretValueCommandInput): Promise<GetSecretValueCommandOutput> =>\n        client.send(new GetSecretValueCommand(input)),\n    };\n  }\n\n  public async discoverPartition(): Promise<string> {\n    return (await this.discoverCurrentAccount()).partition;\n  }\n\n  public async discoverDefaultRegion(): Promise<string> {\n    return loadConfig(NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS)() || 'us-east-1';\n  }\n\n  public async discoverCurrentAccount(): Promise<Account> {\n    if (this.account === undefined) {\n      this.account = await this.getAccount();\n    }\n    return this.account;\n  }\n\n  public async discoverTargetAccount(options: ClientOptions): Promise<Account> {\n    return this.getAccount(await this.awsOptions(options));\n  }\n\n  private async getAccount(options?: ClientOptions): Promise<Account> {\n    this.config.clientConfig = options ?? this.config.clientConfig;\n    const stsClient = new STSClient(await this.awsOptions(options));\n\n    const command = new GetCallerIdentityCommand();\n    const response = await stsClient.send(command);\n    if (!response.Account || !response.Arn) {\n      throw new Error(`Unrecognized response from STS: '${JSON.stringify(response)}'`);\n    }\n    return {\n      accountId: response.Account!,\n      partition: response.Arn!.split(':')[1],\n    };\n  }\n\n  private async awsOptions(options?: ClientOptions) {\n    const config = this.config;\n    config.region = options?.region;\n    if (options) {\n      config.region = options.region;\n      if (options.assumeRoleArn) {\n        config.credentials = fromTemporaryCredentials({\n          params: {\n            RoleArn: options.assumeRoleArn,\n            ExternalId: options.assumeRoleExternalId,\n            RoleSessionName: `${USER_AGENT}-${safeUsername()}`,\n            TransitiveTagKeys: options.assumeRoleAdditionalOptions?.Tags\n              ? options.assumeRoleAdditionalOptions.Tags.map((t) => t.Key!)\n              : undefined,\n            ...options.assumeRoleAdditionalOptions,\n          },\n          clientConfig: this.config.clientConfig,\n        });\n      }\n    }\n    return config;\n  }\n}\n\n/**\n * Return the username with characters invalid for a RoleSessionName removed\n *\n * @see https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html#API_AssumeRole_RequestParameters\n */\nfunction safeUsername() {\n  try {\n    return os.userInfo().username.replace(/[^\\w+=,.@-]/g, '@');\n  } catch {\n    return 'noname';\n  }\n}\n"]}