@rio-cloud/cdk-v2-constructs 8.4.0 → 8.6.0

package/node_modules/@aws-sdk/client-s3/dist-cjs/index.js

@@ -0,0 +1,3064 @@
+'use strict';
+
+var middlewareExpectContinue = require('@aws-sdk/middleware-expect-continue');
+var middlewareFlexibleChecksums = require('@aws-sdk/middleware-flexible-checksums');
+var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
+var middlewareLogger = require('@aws-sdk/middleware-logger');
+var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
+var middlewareSdkS3 = require('@aws-sdk/middleware-sdk-s3');
+var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
+var configResolver = require('@smithy/config-resolver');
+var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
+var eventstreamSerdeConfigResolver = require('@smithy/eventstream-serde-config-resolver');
+var middlewareContentLength = require('@smithy/middleware-content-length');
+var middlewareEndpoint = require('@smithy/middleware-endpoint');
+var middlewareRetry = require('@smithy/middleware-retry');
+var smithyClient = require('@smithy/smithy-client');
+var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
+var schemas_0 = require('./schemas/schemas_0');
+var runtimeConfig = require('./runtimeConfig');
+var regionConfigResolver = require('@aws-sdk/region-config-resolver');
+var protocolHttp = require('@smithy/protocol-http');
+var middlewareSsec = require('@aws-sdk/middleware-ssec');
+var middlewareLocationConstraint = require('@aws-sdk/middleware-location-constraint');
+var utilWaiter = require('@smithy/util-waiter');
+var errors = require('./models/errors');
+var S3ServiceException = require('./models/S3ServiceException');
+
+const resolveClientEndpointParameters = (options) => {
+    return Object.assign(options, {
+        useFipsEndpoint: options.useFipsEndpoint ?? false,
+        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+        forcePathStyle: options.forcePathStyle ?? false,
+        useAccelerateEndpoint: options.useAccelerateEndpoint ?? false,
+        useGlobalEndpoint: options.useGlobalEndpoint ?? false,
+        disableMultiregionAccessPoints: options.disableMultiregionAccessPoints ?? false,
+        defaultSigningName: "s3",
+        clientContextParams: options.clientContextParams ?? {},
+    });
+};
+const commonParams = {
+    ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" },
+    UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
+    DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" },
+    Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" },
+    DisableS3ExpressSessionAuth: { type: "clientContextParams", name: "disableS3ExpressSessionAuth" },
+    UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
+    UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+    Endpoint: { type: "builtInParams", name: "endpoint" },
+    Region: { type: "builtInParams", name: "region" },
+    UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+};
+
+class CreateSessionCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    DisableS3ExpressSessionAuth: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "CreateSession", {})
+    .n("S3Client", "CreateSessionCommand")
+    .sc(schemas_0.CreateSession$)
+    .build() {
+}
+
+const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
+    const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
+    let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
+    let _credentials = runtimeConfig.credentials;
+    return {
+        setHttpAuthScheme(httpAuthScheme) {
+            const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
+            if (index === -1) {
+                _httpAuthSchemes.push(httpAuthScheme);
+            }
+            else {
+                _httpAuthSchemes.splice(index, 1, httpAuthScheme);
+            }
+        },
+        httpAuthSchemes() {
+            return _httpAuthSchemes;
+        },
+        setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
+            _httpAuthSchemeProvider = httpAuthSchemeProvider;
+        },
+        httpAuthSchemeProvider() {
+            return _httpAuthSchemeProvider;
+        },
+        setCredentials(credentials) {
+            _credentials = credentials;
+        },
+        credentials() {
+            return _credentials;
+        },
+    };
+};
+const resolveHttpAuthRuntimeConfig = (config) => {
+    return {
+        httpAuthSchemes: config.httpAuthSchemes(),
+        httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
+        credentials: config.credentials(),
+    };
+};
+
+const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
+    const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
+    extensions.forEach((extension) => extension.configure(extensionConfiguration));
+    return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
+};
+
+class S3Client extends smithyClient.Client {
+    config;
+    constructor(...[configuration]) {
+        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
+        super(_config_0);
+        this.initConfig = _config_0;
+        const _config_1 = resolveClientEndpointParameters(_config_0);
+        const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
+        const _config_3 = middlewareFlexibleChecksums.resolveFlexibleChecksumsConfig(_config_2);
+        const _config_4 = middlewareRetry.resolveRetryConfig(_config_3);
+        const _config_5 = configResolver.resolveRegionConfig(_config_4);
+        const _config_6 = middlewareHostHeader.resolveHostHeaderConfig(_config_5);
+        const _config_7 = middlewareEndpoint.resolveEndpointConfig(_config_6);
+        const _config_8 = eventstreamSerdeConfigResolver.resolveEventStreamSerdeConfig(_config_7);
+        const _config_9 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_8);
+        const _config_10 = middlewareSdkS3.resolveS3Config(_config_9, { session: [() => this, CreateSessionCommand] });
+        const _config_11 = resolveRuntimeExtensions(_config_10, configuration?.extensions || []);
+        this.config = _config_11;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
+        this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
+        this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
+        this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
+        this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
+        this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
+        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
+            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultS3HttpAuthSchemeParametersProvider,
+            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
+                "aws.auth#sigv4": config.credentials,
+                "aws.auth#sigv4a": config.credentials,
+            }),
+        }));
+        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
+        this.middlewareStack.use(middlewareSdkS3.getValidateBucketNamePlugin(this.config));
+        this.middlewareStack.use(middlewareExpectContinue.getAddExpectContinuePlugin(this.config));
+        this.middlewareStack.use(middlewareSdkS3.getRegionRedirectMiddlewarePlugin(this.config));
+        this.middlewareStack.use(middlewareSdkS3.getS3ExpressPlugin(this.config));
+        this.middlewareStack.use(middlewareSdkS3.getS3ExpressHttpSigningPlugin(this.config));
+    }
+    destroy() {
+        super.destroy();
+    }
+}
+
+class AbortMultipartUploadCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+    Key: { type: "contextParams", name: "Key" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "AbortMultipartUpload", {})
+    .n("S3Client", "AbortMultipartUploadCommand")
+    .sc(schemas_0.AbortMultipartUpload$)
+    .build() {
+}
+
+class CompleteMultipartUploadCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+    Key: { type: "contextParams", name: "Key" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+        middlewareSsec.getSsecPlugin(config),
+    ];
+})
+    .s("AmazonS3", "CompleteMultipartUpload", {})
+    .n("S3Client", "CompleteMultipartUploadCommand")
+    .sc(schemas_0.CompleteMultipartUpload$)
+    .build() {
+}
+
+class CopyObjectCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    DisableS3ExpressSessionAuth: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+    Key: { type: "contextParams", name: "Key" },
+    CopySource: { type: "contextParams", name: "CopySource" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+        middlewareSsec.getSsecPlugin(config),
+    ];
+})
+    .s("AmazonS3", "CopyObject", {})
+    .n("S3Client", "CopyObjectCommand")
+    .sc(schemas_0.CopyObject$)
+    .build() {
+}
+
+class CreateBucketCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    DisableAccessPoints: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+        middlewareLocationConstraint.getLocationConstraintPlugin(config),
+    ];
+})
+    .s("AmazonS3", "CreateBucket", {})
+    .n("S3Client", "CreateBucketCommand")
+    .sc(schemas_0.CreateBucket$)
+    .build() {
+}
+
+class CreateBucketMetadataConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: true,
+        }),
+    ];
+})
+    .s("AmazonS3", "CreateBucketMetadataConfiguration", {})
+    .n("S3Client", "CreateBucketMetadataConfigurationCommand")
+    .sc(schemas_0.CreateBucketMetadataConfiguration$)
+    .build() {
+}
+
+class CreateBucketMetadataTableConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: true,
+        }),
+    ];
+})
+    .s("AmazonS3", "CreateBucketMetadataTableConfiguration", {})
+    .n("S3Client", "CreateBucketMetadataTableConfigurationCommand")
+    .sc(schemas_0.CreateBucketMetadataTableConfiguration$)
+    .build() {
+}
+
+class CreateMultipartUploadCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+    Key: { type: "contextParams", name: "Key" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+        middlewareSsec.getSsecPlugin(config),
+    ];
+})
+    .s("AmazonS3", "CreateMultipartUpload", {})
+    .n("S3Client", "CreateMultipartUploadCommand")
+    .sc(schemas_0.CreateMultipartUpload$)
+    .build() {
+}
+
+class DeleteBucketAnalyticsConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonS3", "DeleteBucketAnalyticsConfiguration", {})
+    .n("S3Client", "DeleteBucketAnalyticsConfigurationCommand")
+    .sc(schemas_0.DeleteBucketAnalyticsConfiguration$)
+    .build() {
+}
+
+class DeleteBucketCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonS3", "DeleteBucket", {})
+    .n("S3Client", "DeleteBucketCommand")
+    .sc(schemas_0.DeleteBucket$)
+    .build() {
+}
+
+class DeleteBucketCorsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonS3", "DeleteBucketCors", {})
+    .n("S3Client", "DeleteBucketCorsCommand")
+    .sc(schemas_0.DeleteBucketCors$)
+    .build() {
+}
+
+class DeleteBucketEncryptionCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonS3", "DeleteBucketEncryption", {})
+    .n("S3Client", "DeleteBucketEncryptionCommand")
+    .sc(schemas_0.DeleteBucketEncryption$)
+    .build() {
+}
+
+class DeleteBucketIntelligentTieringConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonS3", "DeleteBucketIntelligentTieringConfiguration", {})
+    .n("S3Client", "DeleteBucketIntelligentTieringConfigurationCommand")
+    .sc(schemas_0.DeleteBucketIntelligentTieringConfiguration$)
+    .build() {
+}
+
+class DeleteBucketInventoryConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonS3", "DeleteBucketInventoryConfiguration", {})
+    .n("S3Client", "DeleteBucketInventoryConfigurationCommand")
+    .sc(schemas_0.DeleteBucketInventoryConfiguration$)
+    .build() {
+}
+
+class DeleteBucketLifecycleCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonS3", "DeleteBucketLifecycle", {})
+    .n("S3Client", "DeleteBucketLifecycleCommand")
+    .sc(schemas_0.DeleteBucketLifecycle$)
+    .build() {
+}
+
+class DeleteBucketMetadataConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonS3", "DeleteBucketMetadataConfiguration", {})
+    .n("S3Client", "DeleteBucketMetadataConfigurationCommand")
+    .sc(schemas_0.DeleteBucketMetadataConfiguration$)
+    .build() {
+}
+
+class DeleteBucketMetadataTableConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonS3", "DeleteBucketMetadataTableConfiguration", {})
+    .n("S3Client", "DeleteBucketMetadataTableConfigurationCommand")
+    .sc(schemas_0.DeleteBucketMetadataTableConfiguration$)
+    .build() {
+}
+
+class DeleteBucketMetricsConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonS3", "DeleteBucketMetricsConfiguration", {})
+    .n("S3Client", "DeleteBucketMetricsConfigurationCommand")
+    .sc(schemas_0.DeleteBucketMetricsConfiguration$)
+    .build() {
+}
+
+class DeleteBucketOwnershipControlsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonS3", "DeleteBucketOwnershipControls", {})
+    .n("S3Client", "DeleteBucketOwnershipControlsCommand")
+    .sc(schemas_0.DeleteBucketOwnershipControls$)
+    .build() {
+}
+
+class DeleteBucketPolicyCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonS3", "DeleteBucketPolicy", {})
+    .n("S3Client", "DeleteBucketPolicyCommand")
+    .sc(schemas_0.DeleteBucketPolicy$)
+    .build() {
+}
+
+class DeleteBucketReplicationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonS3", "DeleteBucketReplication", {})
+    .n("S3Client", "DeleteBucketReplicationCommand")
+    .sc(schemas_0.DeleteBucketReplication$)
+    .build() {
+}
+
+class DeleteBucketTaggingCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonS3", "DeleteBucketTagging", {})
+    .n("S3Client", "DeleteBucketTaggingCommand")
+    .sc(schemas_0.DeleteBucketTagging$)
+    .build() {
+}
+
+class DeleteBucketWebsiteCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonS3", "DeleteBucketWebsite", {})
+    .n("S3Client", "DeleteBucketWebsiteCommand")
+    .sc(schemas_0.DeleteBucketWebsite$)
+    .build() {
+}
+
+class DeleteObjectCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+    Key: { type: "contextParams", name: "Key" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "DeleteObject", {})
+    .n("S3Client", "DeleteObjectCommand")
+    .sc(schemas_0.DeleteObject$)
+    .build() {
+}
+
+class DeleteObjectsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: true,
+        }),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "DeleteObjects", {})
+    .n("S3Client", "DeleteObjectsCommand")
+    .sc(schemas_0.DeleteObjects$)
+    .build() {
+}
+
+class DeleteObjectTaggingCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "DeleteObjectTagging", {})
+    .n("S3Client", "DeleteObjectTaggingCommand")
+    .sc(schemas_0.DeleteObjectTagging$)
+    .build() {
+}
+
+class DeletePublicAccessBlockCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonS3", "DeletePublicAccessBlock", {})
+    .n("S3Client", "DeletePublicAccessBlockCommand")
+    .sc(schemas_0.DeletePublicAccessBlock$)
+    .build() {
+}
+
+class GetBucketAbacCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetBucketAbac", {})
+    .n("S3Client", "GetBucketAbacCommand")
+    .sc(schemas_0.GetBucketAbac$)
+    .build() {
+}
+
+class GetBucketAccelerateConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetBucketAccelerateConfiguration", {})
+    .n("S3Client", "GetBucketAccelerateConfigurationCommand")
+    .sc(schemas_0.GetBucketAccelerateConfiguration$)
+    .build() {
+}
+
+class GetBucketAclCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetBucketAcl", {})
+    .n("S3Client", "GetBucketAclCommand")
+    .sc(schemas_0.GetBucketAcl$)
+    .build() {
+}
+
+class GetBucketAnalyticsConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetBucketAnalyticsConfiguration", {})
+    .n("S3Client", "GetBucketAnalyticsConfigurationCommand")
+    .sc(schemas_0.GetBucketAnalyticsConfiguration$)
+    .build() {
+}
+
+class GetBucketCorsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetBucketCors", {})
+    .n("S3Client", "GetBucketCorsCommand")
+    .sc(schemas_0.GetBucketCors$)
+    .build() {
+}
+
+class GetBucketEncryptionCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetBucketEncryption", {})
+    .n("S3Client", "GetBucketEncryptionCommand")
+    .sc(schemas_0.GetBucketEncryption$)
+    .build() {
+}
+
+class GetBucketIntelligentTieringConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetBucketIntelligentTieringConfiguration", {})
+    .n("S3Client", "GetBucketIntelligentTieringConfigurationCommand")
+    .sc(schemas_0.GetBucketIntelligentTieringConfiguration$)
+    .build() {
+}
+
+class GetBucketInventoryConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetBucketInventoryConfiguration", {})
+    .n("S3Client", "GetBucketInventoryConfigurationCommand")
+    .sc(schemas_0.GetBucketInventoryConfiguration$)
+    .build() {
+}
+
+class GetBucketLifecycleConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetBucketLifecycleConfiguration", {})
+    .n("S3Client", "GetBucketLifecycleConfigurationCommand")
+    .sc(schemas_0.GetBucketLifecycleConfiguration$)
+    .build() {
+}
+
+class GetBucketLocationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetBucketLocation", {})
+    .n("S3Client", "GetBucketLocationCommand")
+    .sc(schemas_0.GetBucketLocation$)
+    .build() {
+}
+
+class GetBucketLoggingCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetBucketLogging", {})
+    .n("S3Client", "GetBucketLoggingCommand")
+    .sc(schemas_0.GetBucketLogging$)
+    .build() {
+}
+
+class GetBucketMetadataConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetBucketMetadataConfiguration", {})
+    .n("S3Client", "GetBucketMetadataConfigurationCommand")
+    .sc(schemas_0.GetBucketMetadataConfiguration$)
+    .build() {
+}
+
+class GetBucketMetadataTableConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetBucketMetadataTableConfiguration", {})
+    .n("S3Client", "GetBucketMetadataTableConfigurationCommand")
+    .sc(schemas_0.GetBucketMetadataTableConfiguration$)
+    .build() {
+}
+
+class GetBucketMetricsConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetBucketMetricsConfiguration", {})
+    .n("S3Client", "GetBucketMetricsConfigurationCommand")
+    .sc(schemas_0.GetBucketMetricsConfiguration$)
+    .build() {
+}
+
+class GetBucketNotificationConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetBucketNotificationConfiguration", {})
+    .n("S3Client", "GetBucketNotificationConfigurationCommand")
+    .sc(schemas_0.GetBucketNotificationConfiguration$)
+    .build() {
+}
+
+class GetBucketOwnershipControlsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetBucketOwnershipControls", {})
+    .n("S3Client", "GetBucketOwnershipControlsCommand")
+    .sc(schemas_0.GetBucketOwnershipControls$)
+    .build() {
+}
+
+class GetBucketPolicyCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonS3", "GetBucketPolicy", {})
+    .n("S3Client", "GetBucketPolicyCommand")
+    .sc(schemas_0.GetBucketPolicy$)
+    .build() {
+}
+
+class GetBucketPolicyStatusCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetBucketPolicyStatus", {})
+    .n("S3Client", "GetBucketPolicyStatusCommand")
+    .sc(schemas_0.GetBucketPolicyStatus$)
+    .build() {
+}
+
+class GetBucketReplicationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetBucketReplication", {})
+    .n("S3Client", "GetBucketReplicationCommand")
+    .sc(schemas_0.GetBucketReplication$)
+    .build() {
+}
+
+class GetBucketRequestPaymentCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetBucketRequestPayment", {})
+    .n("S3Client", "GetBucketRequestPaymentCommand")
+    .sc(schemas_0.GetBucketRequestPayment$)
+    .build() {
+}
+
+class GetBucketTaggingCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetBucketTagging", {})
+    .n("S3Client", "GetBucketTaggingCommand")
+    .sc(schemas_0.GetBucketTagging$)
+    .build() {
+}
+
+class GetBucketVersioningCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetBucketVersioning", {})
+    .n("S3Client", "GetBucketVersioningCommand")
+    .sc(schemas_0.GetBucketVersioning$)
+    .build() {
+}
+
+class GetBucketWebsiteCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetBucketWebsite", {})
+    .n("S3Client", "GetBucketWebsiteCommand")
+    .sc(schemas_0.GetBucketWebsite$)
+    .build() {
+}
+
+class GetObjectAclCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+    Key: { type: "contextParams", name: "Key" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetObjectAcl", {})
+    .n("S3Client", "GetObjectAclCommand")
+    .sc(schemas_0.GetObjectAcl$)
+    .build() {
+}
+
+class GetObjectAttributesCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+        middlewareSsec.getSsecPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetObjectAttributes", {})
+    .n("S3Client", "GetObjectAttributesCommand")
+    .sc(schemas_0.GetObjectAttributes$)
+    .build() {
+}
+
+class GetObjectCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+    Key: { type: "contextParams", name: "Key" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestChecksumRequired: false,
+            requestValidationModeMember: 'ChecksumMode',
+            'responseAlgorithms': ['CRC64NVME', 'CRC32', 'CRC32C', 'SHA256', 'SHA1', 'SHA512', 'MD5', 'XXHASH64', 'XXHASH3', 'XXHASH128'],
+        }),
+        middlewareSsec.getSsecPlugin(config),
+        middlewareSdkS3.getS3ExpiresMiddlewarePlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetObject", {})
+    .n("S3Client", "GetObjectCommand")
+    .sc(schemas_0.GetObject$)
+    .build() {
+}
+
+class GetObjectLegalHoldCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetObjectLegalHold", {})
+    .n("S3Client", "GetObjectLegalHoldCommand")
+    .sc(schemas_0.GetObjectLegalHold$)
+    .build() {
+}
+
+class GetObjectLockConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetObjectLockConfiguration", {})
+    .n("S3Client", "GetObjectLockConfigurationCommand")
+    .sc(schemas_0.GetObjectLockConfiguration$)
+    .build() {
+}
+
+class GetObjectRetentionCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetObjectRetention", {})
+    .n("S3Client", "GetObjectRetentionCommand")
+    .sc(schemas_0.GetObjectRetention$)
+    .build() {
+}
+
+class GetObjectTaggingCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetObjectTagging", {})
+    .n("S3Client", "GetObjectTaggingCommand")
+    .sc(schemas_0.GetObjectTagging$)
+    .build() {
+}
+
+class GetObjectTorrentCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonS3", "GetObjectTorrent", {})
+    .n("S3Client", "GetObjectTorrentCommand")
+    .sc(schemas_0.GetObjectTorrent$)
+    .build() {
+}
+
+class GetPublicAccessBlockCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "GetPublicAccessBlock", {})
+    .n("S3Client", "GetPublicAccessBlockCommand")
+    .sc(schemas_0.GetPublicAccessBlock$)
+    .build() {
+}
+
+class HeadBucketCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "HeadBucket", {})
+    .n("S3Client", "HeadBucketCommand")
+    .sc(schemas_0.HeadBucket$)
+    .build() {
+}
+
+class HeadObjectCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+    Key: { type: "contextParams", name: "Key" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+        middlewareSsec.getSsecPlugin(config),
+        middlewareSdkS3.getS3ExpiresMiddlewarePlugin(config),
+    ];
+})
+    .s("AmazonS3", "HeadObject", {})
+    .n("S3Client", "HeadObjectCommand")
+    .sc(schemas_0.HeadObject$)
+    .build() {
+}
+
+class ListBucketAnalyticsConfigurationsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "ListBucketAnalyticsConfigurations", {})
+    .n("S3Client", "ListBucketAnalyticsConfigurationsCommand")
+    .sc(schemas_0.ListBucketAnalyticsConfigurations$)
+    .build() {
+}
+
+class ListBucketIntelligentTieringConfigurationsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "ListBucketIntelligentTieringConfigurations", {})
+    .n("S3Client", "ListBucketIntelligentTieringConfigurationsCommand")
+    .sc(schemas_0.ListBucketIntelligentTieringConfigurations$)
+    .build() {
+}
+
+class ListBucketInventoryConfigurationsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "ListBucketInventoryConfigurations", {})
+    .n("S3Client", "ListBucketInventoryConfigurationsCommand")
+    .sc(schemas_0.ListBucketInventoryConfigurations$)
+    .build() {
+}
+
+class ListBucketMetricsConfigurationsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "ListBucketMetricsConfigurations", {})
+    .n("S3Client", "ListBucketMetricsConfigurationsCommand")
+    .sc(schemas_0.ListBucketMetricsConfigurations$)
+    .build() {
+}
+
+class ListBucketsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "ListBuckets", {})
+    .n("S3Client", "ListBucketsCommand")
+    .sc(schemas_0.ListBuckets$)
+    .build() {
+}
+
+class ListDirectoryBucketsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "ListDirectoryBuckets", {})
+    .n("S3Client", "ListDirectoryBucketsCommand")
+    .sc(schemas_0.ListDirectoryBuckets$)
+    .build() {
+}
+
+class ListMultipartUploadsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+    Prefix: { type: "contextParams", name: "Prefix" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "ListMultipartUploads", {})
+    .n("S3Client", "ListMultipartUploadsCommand")
+    .sc(schemas_0.ListMultipartUploads$)
+    .build() {
+}
+
+class ListObjectsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+    Prefix: { type: "contextParams", name: "Prefix" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "ListObjects", {})
+    .n("S3Client", "ListObjectsCommand")
+    .sc(schemas_0.ListObjects$)
+    .build() {
+}
+
+class ListObjectsV2Command extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+    Prefix: { type: "contextParams", name: "Prefix" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "ListObjectsV2", {})
+    .n("S3Client", "ListObjectsV2Command")
+    .sc(schemas_0.ListObjectsV2$)
+    .build() {
+}
+
+class ListObjectVersionsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+    Prefix: { type: "contextParams", name: "Prefix" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "ListObjectVersions", {})
+    .n("S3Client", "ListObjectVersionsCommand")
+    .sc(schemas_0.ListObjectVersions$)
+    .build() {
+}
+
+class ListPartsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+    Key: { type: "contextParams", name: "Key" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+        middlewareSsec.getSsecPlugin(config),
+    ];
+})
+    .s("AmazonS3", "ListParts", {})
+    .n("S3Client", "ListPartsCommand")
+    .sc(schemas_0.ListParts$)
+    .build() {
+}
+
+class PutBucketAbacCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: false,
+        }),
+    ];
+})
+    .s("AmazonS3", "PutBucketAbac", {})
+    .n("S3Client", "PutBucketAbacCommand")
+    .sc(schemas_0.PutBucketAbac$)
+    .build() {
+}
+
+class PutBucketAccelerateConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: false,
+        }),
+    ];
+})
+    .s("AmazonS3", "PutBucketAccelerateConfiguration", {})
+    .n("S3Client", "PutBucketAccelerateConfigurationCommand")
+    .sc(schemas_0.PutBucketAccelerateConfiguration$)
+    .build() {
+}
+
+class PutBucketAclCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: true,
+        }),
+    ];
+})
+    .s("AmazonS3", "PutBucketAcl", {})
+    .n("S3Client", "PutBucketAclCommand")
+    .sc(schemas_0.PutBucketAcl$)
+    .build() {
+}
+
+class PutBucketAnalyticsConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonS3", "PutBucketAnalyticsConfiguration", {})
+    .n("S3Client", "PutBucketAnalyticsConfigurationCommand")
+    .sc(schemas_0.PutBucketAnalyticsConfiguration$)
+    .build() {
+}
+
+class PutBucketCorsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: true,
+        }),
+    ];
+})
+    .s("AmazonS3", "PutBucketCors", {})
+    .n("S3Client", "PutBucketCorsCommand")
+    .sc(schemas_0.PutBucketCors$)
+    .build() {
+}
+
+class PutBucketEncryptionCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: true,
+        }),
+    ];
+})
+    .s("AmazonS3", "PutBucketEncryption", {})
+    .n("S3Client", "PutBucketEncryptionCommand")
+    .sc(schemas_0.PutBucketEncryption$)
+    .build() {
+}
+
+class PutBucketIntelligentTieringConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonS3", "PutBucketIntelligentTieringConfiguration", {})
+    .n("S3Client", "PutBucketIntelligentTieringConfigurationCommand")
+    .sc(schemas_0.PutBucketIntelligentTieringConfiguration$)
+    .build() {
+}
+
+class PutBucketInventoryConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonS3", "PutBucketInventoryConfiguration", {})
+    .n("S3Client", "PutBucketInventoryConfigurationCommand")
+    .sc(schemas_0.PutBucketInventoryConfiguration$)
+    .build() {
+}
+
+class PutBucketLifecycleConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: true,
+        }),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "PutBucketLifecycleConfiguration", {})
+    .n("S3Client", "PutBucketLifecycleConfigurationCommand")
+    .sc(schemas_0.PutBucketLifecycleConfiguration$)
+    .build() {
+}
+
+class PutBucketLoggingCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: true,
+        }),
+    ];
+})
+    .s("AmazonS3", "PutBucketLogging", {})
+    .n("S3Client", "PutBucketLoggingCommand")
+    .sc(schemas_0.PutBucketLogging$)
+    .build() {
+}
+
+class PutBucketMetricsConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonS3", "PutBucketMetricsConfiguration", {})
+    .n("S3Client", "PutBucketMetricsConfigurationCommand")
+    .sc(schemas_0.PutBucketMetricsConfiguration$)
+    .build() {
+}
+
+class PutBucketNotificationConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonS3", "PutBucketNotificationConfiguration", {})
+    .n("S3Client", "PutBucketNotificationConfigurationCommand")
+    .sc(schemas_0.PutBucketNotificationConfiguration$)
+    .build() {
+}
+
+class PutBucketOwnershipControlsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: true,
+        }),
+    ];
+})
+    .s("AmazonS3", "PutBucketOwnershipControls", {})
+    .n("S3Client", "PutBucketOwnershipControlsCommand")
+    .sc(schemas_0.PutBucketOwnershipControls$)
+    .build() {
+}
+
+class PutBucketPolicyCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: true,
+        }),
+    ];
+})
+    .s("AmazonS3", "PutBucketPolicy", {})
+    .n("S3Client", "PutBucketPolicyCommand")
+    .sc(schemas_0.PutBucketPolicy$)
+    .build() {
+}
+
+class PutBucketReplicationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: true,
+        }),
+    ];
+})
+    .s("AmazonS3", "PutBucketReplication", {})
+    .n("S3Client", "PutBucketReplicationCommand")
+    .sc(schemas_0.PutBucketReplication$)
+    .build() {
+}
+
+class PutBucketRequestPaymentCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: true,
+        }),
+    ];
+})
+    .s("AmazonS3", "PutBucketRequestPayment", {})
+    .n("S3Client", "PutBucketRequestPaymentCommand")
+    .sc(schemas_0.PutBucketRequestPayment$)
+    .build() {
+}
+
+class PutBucketTaggingCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: true,
+        }),
+    ];
+})
+    .s("AmazonS3", "PutBucketTagging", {})
+    .n("S3Client", "PutBucketTaggingCommand")
+    .sc(schemas_0.PutBucketTagging$)
+    .build() {
+}
+
+class PutBucketVersioningCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: true,
+        }),
+    ];
+})
+    .s("AmazonS3", "PutBucketVersioning", {})
+    .n("S3Client", "PutBucketVersioningCommand")
+    .sc(schemas_0.PutBucketVersioning$)
+    .build() {
+}
+
+class PutBucketWebsiteCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: true,
+        }),
+    ];
+})
+    .s("AmazonS3", "PutBucketWebsite", {})
+    .n("S3Client", "PutBucketWebsiteCommand")
+    .sc(schemas_0.PutBucketWebsite$)
+    .build() {
+}
+
+class PutObjectAclCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+    Key: { type: "contextParams", name: "Key" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: true,
+        }),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "PutObjectAcl", {})
+    .n("S3Client", "PutObjectAclCommand")
+    .sc(schemas_0.PutObjectAcl$)
+    .build() {
+}
+
+class PutObjectCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+    Key: { type: "contextParams", name: "Key" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: false,
+        }),
+        middlewareSdkS3.getCheckContentLengthHeaderPlugin(config),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+        middlewareSsec.getSsecPlugin(config),
+    ];
+})
+    .s("AmazonS3", "PutObject", {})
+    .n("S3Client", "PutObjectCommand")
+    .sc(schemas_0.PutObject$)
+    .build() {
+}
+
+class PutObjectLegalHoldCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: true,
+        }),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "PutObjectLegalHold", {})
+    .n("S3Client", "PutObjectLegalHoldCommand")
+    .sc(schemas_0.PutObjectLegalHold$)
+    .build() {
+}
+
+class PutObjectLockConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: true,
+        }),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "PutObjectLockConfiguration", {})
+    .n("S3Client", "PutObjectLockConfigurationCommand")
+    .sc(schemas_0.PutObjectLockConfiguration$)
+    .build() {
+}
+
+class PutObjectRetentionCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: true,
+        }),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "PutObjectRetention", {})
+    .n("S3Client", "PutObjectRetentionCommand")
+    .sc(schemas_0.PutObjectRetention$)
+    .build() {
+}
+
+class PutObjectTaggingCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: true,
+        }),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "PutObjectTagging", {})
+    .n("S3Client", "PutObjectTaggingCommand")
+    .sc(schemas_0.PutObjectTagging$)
+    .build() {
+}
+
+class PutPublicAccessBlockCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: true,
+        }),
+    ];
+})
+    .s("AmazonS3", "PutPublicAccessBlock", {})
+    .n("S3Client", "PutPublicAccessBlockCommand")
+    .sc(schemas_0.PutPublicAccessBlock$)
+    .build() {
+}
+
+class RenameObjectCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+    Key: { type: "contextParams", name: "Key" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "RenameObject", {})
+    .n("S3Client", "RenameObjectCommand")
+    .sc(schemas_0.RenameObject$)
+    .build() {
+}
+
+class RestoreObjectCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: false,
+        }),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "RestoreObject", {})
+    .n("S3Client", "RestoreObjectCommand")
+    .sc(schemas_0.RestoreObject$)
+    .build() {
+}
+
+class SelectObjectContentCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSsec.getSsecPlugin(config),
+    ];
+})
+    .s("AmazonS3", "SelectObjectContent", {
+    eventStream: {
+        output: true,
+    },
+})
+    .n("S3Client", "SelectObjectContentCommand")
+    .sc(schemas_0.SelectObjectContent$)
+    .build() {
+}
+
+class UpdateBucketMetadataInventoryTableConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: true,
+        }),
+    ];
+})
+    .s("AmazonS3", "UpdateBucketMetadataInventoryTableConfiguration", {})
+    .n("S3Client", "UpdateBucketMetadataInventoryTableConfigurationCommand")
+    .sc(schemas_0.UpdateBucketMetadataInventoryTableConfiguration$)
+    .build() {
+}
+
+class UpdateBucketMetadataJournalTableConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseS3ExpressControlEndpoint: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: true,
+        }),
+    ];
+})
+    .s("AmazonS3", "UpdateBucketMetadataJournalTableConfiguration", {})
+    .n("S3Client", "UpdateBucketMetadataJournalTableConfigurationCommand")
+    .sc(schemas_0.UpdateBucketMetadataJournalTableConfiguration$)
+    .build() {
+}
+
+class UpdateObjectEncryptionCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: true,
+        }),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+    ];
+})
+    .s("AmazonS3", "UpdateObjectEncryption", {})
+    .n("S3Client", "UpdateObjectEncryptionCommand")
+    .sc(schemas_0.UpdateObjectEncryption$)
+    .build() {
+}
+
+class UploadPartCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    Bucket: { type: "contextParams", name: "Bucket" },
+    Key: { type: "contextParams", name: "Key" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareFlexibleChecksums.getFlexibleChecksumsPlugin(config, {
+            requestAlgorithmMember: { 'httpHeader': 'x-amz-sdk-checksum-algorithm', 'name': 'ChecksumAlgorithm' },
+            requestChecksumRequired: false,
+        }),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+        middlewareSsec.getSsecPlugin(config),
+    ];
+})
+    .s("AmazonS3", "UploadPart", {})
+    .n("S3Client", "UploadPartCommand")
+    .sc(schemas_0.UploadPart$)
+    .build() {
+}
+
+class UploadPartCopyCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    DisableS3ExpressSessionAuth: { type: "staticContextParams", value: true },
+    Bucket: { type: "contextParams", name: "Bucket" },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        middlewareSdkS3.getThrow200ExceptionsPlugin(config),
+        middlewareSsec.getSsecPlugin(config),
+    ];
+})
+    .s("AmazonS3", "UploadPartCopy", {})
+    .n("S3Client", "UploadPartCopyCommand")
+    .sc(schemas_0.UploadPartCopy$)
+    .build() {
+}
+
+class WriteGetObjectResponseCommand extends smithyClient.Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    UseObjectLambdaEndpoint: { type: "staticContextParams", value: true },
+})
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("AmazonS3", "WriteGetObjectResponse", {})
+    .n("S3Client", "WriteGetObjectResponseCommand")
+    .sc(schemas_0.WriteGetObjectResponse$)
+    .build() {
+}
+
+const paginateListBuckets = core.createPaginator(S3Client, ListBucketsCommand, "ContinuationToken", "ContinuationToken", "MaxBuckets");
+
+const paginateListDirectoryBuckets = core.createPaginator(S3Client, ListDirectoryBucketsCommand, "ContinuationToken", "ContinuationToken", "MaxDirectoryBuckets");
+
+const paginateListObjectsV2 = core.createPaginator(S3Client, ListObjectsV2Command, "ContinuationToken", "NextContinuationToken", "MaxKeys");
+
+const paginateListParts = core.createPaginator(S3Client, ListPartsCommand, "PartNumberMarker", "NextPartNumberMarker", "MaxParts");
+
+const checkState$3 = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.send(new HeadBucketCommand(input));
+        reason = result;
+        return { state: utilWaiter.WaiterState.SUCCESS, reason };
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "NotFound") {
+            return { state: utilWaiter.WaiterState.RETRY, reason };
+        }
+    }
+    return { state: utilWaiter.WaiterState.RETRY, reason };
+};
+const waitForBucketExists = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
+};
+const waitUntilBucketExists = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
+    return utilWaiter.checkExceptions(result);
+};
+
+const checkState$2 = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.send(new HeadBucketCommand(input));
+        reason = result;
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "NotFound") {
+            return { state: utilWaiter.WaiterState.SUCCESS, reason };
+        }
+    }
+    return { state: utilWaiter.WaiterState.RETRY, reason };
+};
+const waitForBucketNotExists = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+};
+const waitUntilBucketNotExists = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+    return utilWaiter.checkExceptions(result);
+};
+
+const checkState$1 = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.send(new HeadObjectCommand(input));
+        reason = result;
+        return { state: utilWaiter.WaiterState.SUCCESS, reason };
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "NotFound") {
+            return { state: utilWaiter.WaiterState.RETRY, reason };
+        }
+    }
+    return { state: utilWaiter.WaiterState.RETRY, reason };
+};
+const waitForObjectExists = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+};
+const waitUntilObjectExists = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return utilWaiter.checkExceptions(result);
+};
+
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.send(new HeadObjectCommand(input));
+        reason = result;
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "NotFound") {
+            return { state: utilWaiter.WaiterState.SUCCESS, reason };
+        }
+    }
+    return { state: utilWaiter.WaiterState.RETRY, reason };
+};
+const waitForObjectNotExists = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+const waitUntilObjectNotExists = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return utilWaiter.checkExceptions(result);
+};
+
+const commands = {
+    AbortMultipartUploadCommand,
+    CompleteMultipartUploadCommand,
+    CopyObjectCommand,
+    CreateBucketCommand,
+    CreateBucketMetadataConfigurationCommand,
+    CreateBucketMetadataTableConfigurationCommand,
+    CreateMultipartUploadCommand,
+    CreateSessionCommand,
+    DeleteBucketCommand,
+    DeleteBucketAnalyticsConfigurationCommand,
+    DeleteBucketCorsCommand,
+    DeleteBucketEncryptionCommand,
+    DeleteBucketIntelligentTieringConfigurationCommand,
+    DeleteBucketInventoryConfigurationCommand,
+    DeleteBucketLifecycleCommand,
+    DeleteBucketMetadataConfigurationCommand,
+    DeleteBucketMetadataTableConfigurationCommand,
+    DeleteBucketMetricsConfigurationCommand,
+    DeleteBucketOwnershipControlsCommand,
+    DeleteBucketPolicyCommand,
+    DeleteBucketReplicationCommand,
+    DeleteBucketTaggingCommand,
+    DeleteBucketWebsiteCommand,
+    DeleteObjectCommand,
+    DeleteObjectsCommand,
+    DeleteObjectTaggingCommand,
+    DeletePublicAccessBlockCommand,
+    GetBucketAbacCommand,
+    GetBucketAccelerateConfigurationCommand,
+    GetBucketAclCommand,
+    GetBucketAnalyticsConfigurationCommand,
+    GetBucketCorsCommand,
+    GetBucketEncryptionCommand,
+    GetBucketIntelligentTieringConfigurationCommand,
+    GetBucketInventoryConfigurationCommand,
+    GetBucketLifecycleConfigurationCommand,
+    GetBucketLocationCommand,
+    GetBucketLoggingCommand,
+    GetBucketMetadataConfigurationCommand,
+    GetBucketMetadataTableConfigurationCommand,
+    GetBucketMetricsConfigurationCommand,
+    GetBucketNotificationConfigurationCommand,
+    GetBucketOwnershipControlsCommand,
+    GetBucketPolicyCommand,
+    GetBucketPolicyStatusCommand,
+    GetBucketReplicationCommand,
+    GetBucketRequestPaymentCommand,
+    GetBucketTaggingCommand,
+    GetBucketVersioningCommand,
+    GetBucketWebsiteCommand,
+    GetObjectCommand,
+    GetObjectAclCommand,
+    GetObjectAttributesCommand,
+    GetObjectLegalHoldCommand,
+    GetObjectLockConfigurationCommand,
+    GetObjectRetentionCommand,
+    GetObjectTaggingCommand,
+    GetObjectTorrentCommand,
+    GetPublicAccessBlockCommand,
+    HeadBucketCommand,
+    HeadObjectCommand,
+    ListBucketAnalyticsConfigurationsCommand,
+    ListBucketIntelligentTieringConfigurationsCommand,
+    ListBucketInventoryConfigurationsCommand,
+    ListBucketMetricsConfigurationsCommand,
+    ListBucketsCommand,
+    ListDirectoryBucketsCommand,
+    ListMultipartUploadsCommand,
+    ListObjectsCommand,
+    ListObjectsV2Command,
+    ListObjectVersionsCommand,
+    ListPartsCommand,
+    PutBucketAbacCommand,
+    PutBucketAccelerateConfigurationCommand,
+    PutBucketAclCommand,
+    PutBucketAnalyticsConfigurationCommand,
+    PutBucketCorsCommand,
+    PutBucketEncryptionCommand,
+    PutBucketIntelligentTieringConfigurationCommand,
+    PutBucketInventoryConfigurationCommand,
+    PutBucketLifecycleConfigurationCommand,
+    PutBucketLoggingCommand,
+    PutBucketMetricsConfigurationCommand,
+    PutBucketNotificationConfigurationCommand,
+    PutBucketOwnershipControlsCommand,
+    PutBucketPolicyCommand,
+    PutBucketReplicationCommand,
+    PutBucketRequestPaymentCommand,
+    PutBucketTaggingCommand,
+    PutBucketVersioningCommand,
+    PutBucketWebsiteCommand,
+    PutObjectCommand,
+    PutObjectAclCommand,
+    PutObjectLegalHoldCommand,
+    PutObjectLockConfigurationCommand,
+    PutObjectRetentionCommand,
+    PutObjectTaggingCommand,
+    PutPublicAccessBlockCommand,
+    RenameObjectCommand,
+    RestoreObjectCommand,
+    SelectObjectContentCommand,
+    UpdateBucketMetadataInventoryTableConfigurationCommand,
+    UpdateBucketMetadataJournalTableConfigurationCommand,
+    UpdateObjectEncryptionCommand,
+    UploadPartCommand,
+    UploadPartCopyCommand,
+    WriteGetObjectResponseCommand,
+};
+const paginators = {
+    paginateListBuckets,
+    paginateListDirectoryBuckets,
+    paginateListObjectsV2,
+    paginateListParts,
+};
+const waiters = {
+    waitUntilBucketExists,
+    waitUntilBucketNotExists,
+    waitUntilObjectExists,
+    waitUntilObjectNotExists,
+};
+class S3 extends S3Client {
+}
+smithyClient.createAggregatedClient(commands, S3, { paginators, waiters });
+
+const BucketAbacStatus = {
+    Disabled: "Disabled",
+    Enabled: "Enabled",
+};
+const RequestCharged = {
+    requester: "requester",
+};
+const RequestPayer = {
+    requester: "requester",
+};
+const BucketAccelerateStatus = {
+    Enabled: "Enabled",
+    Suspended: "Suspended",
+};
+const Type = {
+    AmazonCustomerByEmail: "AmazonCustomerByEmail",
+    CanonicalUser: "CanonicalUser",
+    Group: "Group",
+};
+const Permission = {
+    FULL_CONTROL: "FULL_CONTROL",
+    READ: "READ",
+    READ_ACP: "READ_ACP",
+    WRITE: "WRITE",
+    WRITE_ACP: "WRITE_ACP",
+};
+const OwnerOverride = {
+    Destination: "Destination",
+};
+const ChecksumType = {
+    COMPOSITE: "COMPOSITE",
+    FULL_OBJECT: "FULL_OBJECT",
+};
+const ServerSideEncryption = {
+    AES256: "AES256",
+    aws_fsx: "aws:fsx",
+    aws_kms: "aws:kms",
+    aws_kms_dsse: "aws:kms:dsse",
+};
+const 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",
+};
+const ChecksumAlgorithm = {
+    CRC32: "CRC32",
+    CRC32C: "CRC32C",
+    CRC64NVME: "CRC64NVME",
+    MD5: "MD5",
+    SHA1: "SHA1",
+    SHA256: "SHA256",
+    SHA512: "SHA512",
+    XXHASH128: "XXHASH128",
+    XXHASH3: "XXHASH3",
+    XXHASH64: "XXHASH64",
+};
+const MetadataDirective = {
+    COPY: "COPY",
+    REPLACE: "REPLACE",
+};
+const ObjectLockLegalHoldStatus = {
+    OFF: "OFF",
+    ON: "ON",
+};
+const ObjectLockMode = {
+    COMPLIANCE: "COMPLIANCE",
+    GOVERNANCE: "GOVERNANCE",
+};
+const StorageClass = {
+    DEEP_ARCHIVE: "DEEP_ARCHIVE",
+    EXPRESS_ONEZONE: "EXPRESS_ONEZONE",
+    FSX_ONTAP: "FSX_ONTAP",
+    FSX_OPENZFS: "FSX_OPENZFS",
+    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",
+};
+const TaggingDirective = {
+    COPY: "COPY",
+    REPLACE: "REPLACE",
+};
+const BucketCannedACL = {
+    authenticated_read: "authenticated-read",
+    private: "private",
+    public_read: "public-read",
+    public_read_write: "public-read-write",
+};
+const BucketNamespace = {
+    ACCOUNT_REGIONAL: "account-regional",
+    GLOBAL: "global",
+};
+const DataRedundancy = {
+    SingleAvailabilityZone: "SingleAvailabilityZone",
+    SingleLocalZone: "SingleLocalZone",
+};
+const BucketType = {
+    Directory: "Directory",
+};
+const LocationType = {
+    AvailabilityZone: "AvailabilityZone",
+    LocalZone: "LocalZone",
+};
+const BucketLocationConstraint = {
+    EU: "EU",
+    af_south_1: "af-south-1",
+    ap_east_1: "ap-east-1",
+    ap_east_2: "ap-east-2",
+    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",
+    ap_southeast_4: "ap-southeast-4",
+    ap_southeast_5: "ap-southeast-5",
+    ap_southeast_6: "ap-southeast-6",
+    ap_southeast_7: "ap-southeast-7",
+    ca_central_1: "ca-central-1",
+    ca_west_1: "ca-west-1",
+    cn_north_1: "cn-north-1",
+    cn_northwest_1: "cn-northwest-1",
+    eu_central_1: "eu-central-1",
+    eu_central_2: "eu-central-2",
+    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",
+    il_central_1: "il-central-1",
+    me_central_1: "me-central-1",
+    me_south_1: "me-south-1",
+    mx_central_1: "mx-central-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",
+};
+const ObjectOwnership = {
+    BucketOwnerEnforced: "BucketOwnerEnforced",
+    BucketOwnerPreferred: "BucketOwnerPreferred",
+    ObjectWriter: "ObjectWriter",
+};
+const InventoryConfigurationState = {
+    DISABLED: "DISABLED",
+    ENABLED: "ENABLED",
+};
+const TableSseAlgorithm = {
+    AES256: "AES256",
+    aws_kms: "aws:kms",
+};
+const ExpirationState = {
+    DISABLED: "DISABLED",
+    ENABLED: "ENABLED",
+};
+const SessionMode = {
+    ReadOnly: "ReadOnly",
+    ReadWrite: "ReadWrite",
+};
+const AnalyticsS3ExportFileFormat = {
+    CSV: "CSV",
+};
+const StorageClassAnalysisSchemaVersion = {
+    V_1: "V_1",
+};
+const EncryptionType = {
+    NONE: "NONE",
+    SSE_C: "SSE-C",
+};
+const IntelligentTieringStatus = {
+    Disabled: "Disabled",
+    Enabled: "Enabled",
+};
+const IntelligentTieringAccessTier = {
+    ARCHIVE_ACCESS: "ARCHIVE_ACCESS",
+    DEEP_ARCHIVE_ACCESS: "DEEP_ARCHIVE_ACCESS",
+};
+const InventoryFormat = {
+    CSV: "CSV",
+    ORC: "ORC",
+    Parquet: "Parquet",
+};
+const InventoryIncludedObjectVersions = {
+    All: "All",
+    Current: "Current",
+};
+const InventoryOptionalField = {
+    BucketKeyStatus: "BucketKeyStatus",
+    ChecksumAlgorithm: "ChecksumAlgorithm",
+    ETag: "ETag",
+    EncryptionStatus: "EncryptionStatus",
+    IntelligentTieringAccessTier: "IntelligentTieringAccessTier",
+    IsMultipartUploaded: "IsMultipartUploaded",
+    LastModifiedDate: "LastModifiedDate",
+    LifecycleExpirationDate: "LifecycleExpirationDate",
+    ObjectAccessControlList: "ObjectAccessControlList",
+    ObjectLockLegalHoldStatus: "ObjectLockLegalHoldStatus",
+    ObjectLockMode: "ObjectLockMode",
+    ObjectLockRetainUntilDate: "ObjectLockRetainUntilDate",
+    ObjectOwner: "ObjectOwner",
+    ReplicationStatus: "ReplicationStatus",
+    Size: "Size",
+    StorageClass: "StorageClass",
+};
+const InventoryFrequency = {
+    Daily: "Daily",
+    Weekly: "Weekly",
+};
+const TransitionStorageClass = {
+    DEEP_ARCHIVE: "DEEP_ARCHIVE",
+    GLACIER: "GLACIER",
+    GLACIER_IR: "GLACIER_IR",
+    INTELLIGENT_TIERING: "INTELLIGENT_TIERING",
+    ONEZONE_IA: "ONEZONE_IA",
+    STANDARD_IA: "STANDARD_IA",
+};
+const ExpirationStatus = {
+    Disabled: "Disabled",
+    Enabled: "Enabled",
+};
+const TransitionDefaultMinimumObjectSize = {
+    all_storage_classes_128K: "all_storage_classes_128K",
+    varies_by_storage_class: "varies_by_storage_class",
+};
+const BucketLogsPermission = {
+    FULL_CONTROL: "FULL_CONTROL",
+    READ: "READ",
+    WRITE: "WRITE",
+};
+const PartitionDateSource = {
+    DeliveryTime: "DeliveryTime",
+    EventTime: "EventTime",
+};
+const S3TablesBucketType = {
+    aws: "aws",
+    customer: "customer",
+};
+const Event = {
+    s3_IntelligentTiering: "s3:IntelligentTiering",
+    s3_LifecycleExpiration_: "s3:LifecycleExpiration:*",
+    s3_LifecycleExpiration_Delete: "s3:LifecycleExpiration:Delete",
+    s3_LifecycleExpiration_DeleteMarkerCreated: "s3:LifecycleExpiration:DeleteMarkerCreated",
+    s3_LifecycleTransition: "s3:LifecycleTransition",
+    s3_ObjectAcl_Put: "s3:ObjectAcl:Put",
+    s3_ObjectCreated_: "s3:ObjectCreated:*",
+    s3_ObjectCreated_CompleteMultipartUpload: "s3:ObjectCreated:CompleteMultipartUpload",
+    s3_ObjectCreated_Copy: "s3:ObjectCreated:Copy",
+    s3_ObjectCreated_Post: "s3:ObjectCreated:Post",
+    s3_ObjectCreated_Put: "s3:ObjectCreated:Put",
+    s3_ObjectRemoved_: "s3:ObjectRemoved:*",
+    s3_ObjectRemoved_Delete: "s3:ObjectRemoved:Delete",
+    s3_ObjectRemoved_DeleteMarkerCreated: "s3:ObjectRemoved:DeleteMarkerCreated",
+    s3_ObjectRestore_: "s3:ObjectRestore:*",
+    s3_ObjectRestore_Completed: "s3:ObjectRestore:Completed",
+    s3_ObjectRestore_Delete: "s3:ObjectRestore:Delete",
+    s3_ObjectRestore_Post: "s3:ObjectRestore:Post",
+    s3_ObjectTagging_: "s3:ObjectTagging:*",
+    s3_ObjectTagging_Delete: "s3:ObjectTagging:Delete",
+    s3_ObjectTagging_Put: "s3:ObjectTagging:Put",
+    s3_ReducedRedundancyLostObject: "s3:ReducedRedundancyLostObject",
+    s3_Replication_: "s3:Replication:*",
+    s3_Replication_OperationFailedReplication: "s3:Replication:OperationFailedReplication",
+    s3_Replication_OperationMissedThreshold: "s3:Replication:OperationMissedThreshold",
+    s3_Replication_OperationNotTracked: "s3:Replication:OperationNotTracked",
+    s3_Replication_OperationReplicatedAfterThreshold: "s3:Replication:OperationReplicatedAfterThreshold",
+};
+const FilterRuleName = {
+    prefix: "prefix",
+    suffix: "suffix",
+};
+const DeleteMarkerReplicationStatus = {
+    Disabled: "Disabled",
+    Enabled: "Enabled",
+};
+const MetricsStatus = {
+    Disabled: "Disabled",
+    Enabled: "Enabled",
+};
+const ReplicationTimeStatus = {
+    Disabled: "Disabled",
+    Enabled: "Enabled",
+};
+const ExistingObjectReplicationStatus = {
+    Disabled: "Disabled",
+    Enabled: "Enabled",
+};
+const ReplicaModificationsStatus = {
+    Disabled: "Disabled",
+    Enabled: "Enabled",
+};
+const SseKmsEncryptedObjectsStatus = {
+    Disabled: "Disabled",
+    Enabled: "Enabled",
+};
+const ReplicationRuleStatus = {
+    Disabled: "Disabled",
+    Enabled: "Enabled",
+};
+const Payer = {
+    BucketOwner: "BucketOwner",
+    Requester: "Requester",
+};
+const MFADeleteStatus = {
+    Disabled: "Disabled",
+    Enabled: "Enabled",
+};
+const BucketVersioningStatus = {
+    Enabled: "Enabled",
+    Suspended: "Suspended",
+};
+const Protocol = {
+    http: "http",
+    https: "https",
+};
+const ReplicationStatus = {
+    COMPLETE: "COMPLETE",
+    COMPLETED: "COMPLETED",
+    FAILED: "FAILED",
+    PENDING: "PENDING",
+    REPLICA: "REPLICA",
+};
+const ChecksumMode = {
+    ENABLED: "ENABLED",
+};
+const ObjectAttributes = {
+    CHECKSUM: "Checksum",
+    ETAG: "ETag",
+    OBJECT_PARTS: "ObjectParts",
+    OBJECT_SIZE: "ObjectSize",
+    STORAGE_CLASS: "StorageClass",
+};
+const ObjectLockEnabled = {
+    Enabled: "Enabled",
+};
+const ObjectLockRetentionMode = {
+    COMPLIANCE: "COMPLIANCE",
+    GOVERNANCE: "GOVERNANCE",
+};
+const ArchiveStatus = {
+    ARCHIVE_ACCESS: "ARCHIVE_ACCESS",
+    DEEP_ARCHIVE_ACCESS: "DEEP_ARCHIVE_ACCESS",
+};
+const EncodingType = {
+    url: "url",
+};
+const ObjectStorageClass = {
+    DEEP_ARCHIVE: "DEEP_ARCHIVE",
+    EXPRESS_ONEZONE: "EXPRESS_ONEZONE",
+    FSX_ONTAP: "FSX_ONTAP",
+    FSX_OPENZFS: "FSX_OPENZFS",
+    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",
+};
+const OptionalObjectAttributes = {
+    RESTORE_STATUS: "RestoreStatus",
+};
+const ObjectVersionStorageClass = {
+    STANDARD: "STANDARD",
+};
+const MFADelete = {
+    Disabled: "Disabled",
+    Enabled: "Enabled",
+};
+const Tier = {
+    Bulk: "Bulk",
+    Expedited: "Expedited",
+    Standard: "Standard",
+};
+const ExpressionType = {
+    SQL: "SQL",
+};
+const CompressionType = {
+    BZIP2: "BZIP2",
+    GZIP: "GZIP",
+    NONE: "NONE",
+};
+const FileHeaderInfo = {
+    IGNORE: "IGNORE",
+    NONE: "NONE",
+    USE: "USE",
+};
+const JSONType = {
+    DOCUMENT: "DOCUMENT",
+    LINES: "LINES",
+};
+const QuoteFields = {
+    ALWAYS: "ALWAYS",
+    ASNEEDED: "ASNEEDED",
+};
+const RestoreRequestType = {
+    SELECT: "SELECT",
+};
+
+exports.$Command = smithyClient.Command;
+exports.__Client = smithyClient.Client;
+exports.S3ServiceException = S3ServiceException.S3ServiceException;
+exports.AbortMultipartUploadCommand = AbortMultipartUploadCommand;
+exports.AnalyticsS3ExportFileFormat = AnalyticsS3ExportFileFormat;
+exports.ArchiveStatus = ArchiveStatus;
+exports.BucketAbacStatus = BucketAbacStatus;
+exports.BucketAccelerateStatus = BucketAccelerateStatus;
+exports.BucketCannedACL = BucketCannedACL;
+exports.BucketLocationConstraint = BucketLocationConstraint;
+exports.BucketLogsPermission = BucketLogsPermission;
+exports.BucketNamespace = BucketNamespace;
+exports.BucketType = BucketType;
+exports.BucketVersioningStatus = BucketVersioningStatus;
+exports.ChecksumAlgorithm = ChecksumAlgorithm;
+exports.ChecksumMode = ChecksumMode;
+exports.ChecksumType = ChecksumType;
+exports.CompleteMultipartUploadCommand = CompleteMultipartUploadCommand;
+exports.CompressionType = CompressionType;
+exports.CopyObjectCommand = CopyObjectCommand;
+exports.CreateBucketCommand = CreateBucketCommand;
+exports.CreateBucketMetadataConfigurationCommand = CreateBucketMetadataConfigurationCommand;
+exports.CreateBucketMetadataTableConfigurationCommand = CreateBucketMetadataTableConfigurationCommand;
+exports.CreateMultipartUploadCommand = CreateMultipartUploadCommand;
+exports.CreateSessionCommand = CreateSessionCommand;
+exports.DataRedundancy = DataRedundancy;
+exports.DeleteBucketAnalyticsConfigurationCommand = DeleteBucketAnalyticsConfigurationCommand;
+exports.DeleteBucketCommand = DeleteBucketCommand;
+exports.DeleteBucketCorsCommand = DeleteBucketCorsCommand;
+exports.DeleteBucketEncryptionCommand = DeleteBucketEncryptionCommand;
+exports.DeleteBucketIntelligentTieringConfigurationCommand = DeleteBucketIntelligentTieringConfigurationCommand;
+exports.DeleteBucketInventoryConfigurationCommand = DeleteBucketInventoryConfigurationCommand;
+exports.DeleteBucketLifecycleCommand = DeleteBucketLifecycleCommand;
+exports.DeleteBucketMetadataConfigurationCommand = DeleteBucketMetadataConfigurationCommand;
+exports.DeleteBucketMetadataTableConfigurationCommand = DeleteBucketMetadataTableConfigurationCommand;
+exports.DeleteBucketMetricsConfigurationCommand = DeleteBucketMetricsConfigurationCommand;
+exports.DeleteBucketOwnershipControlsCommand = DeleteBucketOwnershipControlsCommand;
+exports.DeleteBucketPolicyCommand = DeleteBucketPolicyCommand;
+exports.DeleteBucketReplicationCommand = DeleteBucketReplicationCommand;
+exports.DeleteBucketTaggingCommand = DeleteBucketTaggingCommand;
+exports.DeleteBucketWebsiteCommand = DeleteBucketWebsiteCommand;
+exports.DeleteMarkerReplicationStatus = DeleteMarkerReplicationStatus;
+exports.DeleteObjectCommand = DeleteObjectCommand;
+exports.DeleteObjectTaggingCommand = DeleteObjectTaggingCommand;
+exports.DeleteObjectsCommand = DeleteObjectsCommand;
+exports.DeletePublicAccessBlockCommand = DeletePublicAccessBlockCommand;
+exports.EncodingType = EncodingType;
+exports.EncryptionType = EncryptionType;
+exports.Event = Event;
+exports.ExistingObjectReplicationStatus = ExistingObjectReplicationStatus;
+exports.ExpirationState = ExpirationState;
+exports.ExpirationStatus = ExpirationStatus;
+exports.ExpressionType = ExpressionType;
+exports.FileHeaderInfo = FileHeaderInfo;
+exports.FilterRuleName = FilterRuleName;
+exports.GetBucketAbacCommand = GetBucketAbacCommand;
+exports.GetBucketAccelerateConfigurationCommand = GetBucketAccelerateConfigurationCommand;
+exports.GetBucketAclCommand = GetBucketAclCommand;
+exports.GetBucketAnalyticsConfigurationCommand = GetBucketAnalyticsConfigurationCommand;
+exports.GetBucketCorsCommand = GetBucketCorsCommand;
+exports.GetBucketEncryptionCommand = GetBucketEncryptionCommand;
+exports.GetBucketIntelligentTieringConfigurationCommand = GetBucketIntelligentTieringConfigurationCommand;
+exports.GetBucketInventoryConfigurationCommand = GetBucketInventoryConfigurationCommand;
+exports.GetBucketLifecycleConfigurationCommand = GetBucketLifecycleConfigurationCommand;
+exports.GetBucketLocationCommand = GetBucketLocationCommand;
+exports.GetBucketLoggingCommand = GetBucketLoggingCommand;
+exports.GetBucketMetadataConfigurationCommand = GetBucketMetadataConfigurationCommand;
+exports.GetBucketMetadataTableConfigurationCommand = GetBucketMetadataTableConfigurationCommand;
+exports.GetBucketMetricsConfigurationCommand = GetBucketMetricsConfigurationCommand;
+exports.GetBucketNotificationConfigurationCommand = GetBucketNotificationConfigurationCommand;
+exports.GetBucketOwnershipControlsCommand = GetBucketOwnershipControlsCommand;
+exports.GetBucketPolicyCommand = GetBucketPolicyCommand;
+exports.GetBucketPolicyStatusCommand = GetBucketPolicyStatusCommand;
+exports.GetBucketReplicationCommand = GetBucketReplicationCommand;
+exports.GetBucketRequestPaymentCommand = GetBucketRequestPaymentCommand;
+exports.GetBucketTaggingCommand = GetBucketTaggingCommand;
+exports.GetBucketVersioningCommand = GetBucketVersioningCommand;
+exports.GetBucketWebsiteCommand = GetBucketWebsiteCommand;
+exports.GetObjectAclCommand = GetObjectAclCommand;
+exports.GetObjectAttributesCommand = GetObjectAttributesCommand;
+exports.GetObjectCommand = GetObjectCommand;
+exports.GetObjectLegalHoldCommand = GetObjectLegalHoldCommand;
+exports.GetObjectLockConfigurationCommand = GetObjectLockConfigurationCommand;
+exports.GetObjectRetentionCommand = GetObjectRetentionCommand;
+exports.GetObjectTaggingCommand = GetObjectTaggingCommand;
+exports.GetObjectTorrentCommand = GetObjectTorrentCommand;
+exports.GetPublicAccessBlockCommand = GetPublicAccessBlockCommand;
+exports.HeadBucketCommand = HeadBucketCommand;
+exports.HeadObjectCommand = HeadObjectCommand;
+exports.IntelligentTieringAccessTier = IntelligentTieringAccessTier;
+exports.IntelligentTieringStatus = IntelligentTieringStatus;
+exports.InventoryConfigurationState = InventoryConfigurationState;
+exports.InventoryFormat = InventoryFormat;
+exports.InventoryFrequency = InventoryFrequency;
+exports.InventoryIncludedObjectVersions = InventoryIncludedObjectVersions;
+exports.InventoryOptionalField = InventoryOptionalField;
+exports.JSONType = JSONType;
+exports.ListBucketAnalyticsConfigurationsCommand = ListBucketAnalyticsConfigurationsCommand;
+exports.ListBucketIntelligentTieringConfigurationsCommand = ListBucketIntelligentTieringConfigurationsCommand;
+exports.ListBucketInventoryConfigurationsCommand = ListBucketInventoryConfigurationsCommand;
+exports.ListBucketMetricsConfigurationsCommand = ListBucketMetricsConfigurationsCommand;
+exports.ListBucketsCommand = ListBucketsCommand;
+exports.ListDirectoryBucketsCommand = ListDirectoryBucketsCommand;
+exports.ListMultipartUploadsCommand = ListMultipartUploadsCommand;
+exports.ListObjectVersionsCommand = ListObjectVersionsCommand;
+exports.ListObjectsCommand = ListObjectsCommand;
+exports.ListObjectsV2Command = ListObjectsV2Command;
+exports.ListPartsCommand = ListPartsCommand;
+exports.LocationType = LocationType;
+exports.MFADelete = MFADelete;
+exports.MFADeleteStatus = MFADeleteStatus;
+exports.MetadataDirective = MetadataDirective;
+exports.MetricsStatus = MetricsStatus;
+exports.ObjectAttributes = ObjectAttributes;
+exports.ObjectCannedACL = ObjectCannedACL;
+exports.ObjectLockEnabled = ObjectLockEnabled;
+exports.ObjectLockLegalHoldStatus = ObjectLockLegalHoldStatus;
+exports.ObjectLockMode = ObjectLockMode;
+exports.ObjectLockRetentionMode = ObjectLockRetentionMode;
+exports.ObjectOwnership = ObjectOwnership;
+exports.ObjectStorageClass = ObjectStorageClass;
+exports.ObjectVersionStorageClass = ObjectVersionStorageClass;
+exports.OptionalObjectAttributes = OptionalObjectAttributes;
+exports.OwnerOverride = OwnerOverride;
+exports.PartitionDateSource = PartitionDateSource;
+exports.Payer = Payer;
+exports.Permission = Permission;
+exports.Protocol = Protocol;
+exports.PutBucketAbacCommand = PutBucketAbacCommand;
+exports.PutBucketAccelerateConfigurationCommand = PutBucketAccelerateConfigurationCommand;
+exports.PutBucketAclCommand = PutBucketAclCommand;
+exports.PutBucketAnalyticsConfigurationCommand = PutBucketAnalyticsConfigurationCommand;
+exports.PutBucketCorsCommand = PutBucketCorsCommand;
+exports.PutBucketEncryptionCommand = PutBucketEncryptionCommand;
+exports.PutBucketIntelligentTieringConfigurationCommand = PutBucketIntelligentTieringConfigurationCommand;
+exports.PutBucketInventoryConfigurationCommand = PutBucketInventoryConfigurationCommand;
+exports.PutBucketLifecycleConfigurationCommand = PutBucketLifecycleConfigurationCommand;
+exports.PutBucketLoggingCommand = PutBucketLoggingCommand;
+exports.PutBucketMetricsConfigurationCommand = PutBucketMetricsConfigurationCommand;
+exports.PutBucketNotificationConfigurationCommand = PutBucketNotificationConfigurationCommand;
+exports.PutBucketOwnershipControlsCommand = PutBucketOwnershipControlsCommand;
+exports.PutBucketPolicyCommand = PutBucketPolicyCommand;
+exports.PutBucketReplicationCommand = PutBucketReplicationCommand;
+exports.PutBucketRequestPaymentCommand = PutBucketRequestPaymentCommand;
+exports.PutBucketTaggingCommand = PutBucketTaggingCommand;
+exports.PutBucketVersioningCommand = PutBucketVersioningCommand;
+exports.PutBucketWebsiteCommand = PutBucketWebsiteCommand;
+exports.PutObjectAclCommand = PutObjectAclCommand;
+exports.PutObjectCommand = PutObjectCommand;
+exports.PutObjectLegalHoldCommand = PutObjectLegalHoldCommand;
+exports.PutObjectLockConfigurationCommand = PutObjectLockConfigurationCommand;
+exports.PutObjectRetentionCommand = PutObjectRetentionCommand;
+exports.PutObjectTaggingCommand = PutObjectTaggingCommand;
+exports.PutPublicAccessBlockCommand = PutPublicAccessBlockCommand;
+exports.QuoteFields = QuoteFields;
+exports.RenameObjectCommand = RenameObjectCommand;
+exports.ReplicaModificationsStatus = ReplicaModificationsStatus;
+exports.ReplicationRuleStatus = ReplicationRuleStatus;
+exports.ReplicationStatus = ReplicationStatus;
+exports.ReplicationTimeStatus = ReplicationTimeStatus;
+exports.RequestCharged = RequestCharged;
+exports.RequestPayer = RequestPayer;
+exports.RestoreObjectCommand = RestoreObjectCommand;
+exports.RestoreRequestType = RestoreRequestType;
+exports.S3 = S3;
+exports.S3Client = S3Client;
+exports.S3TablesBucketType = S3TablesBucketType;
+exports.SelectObjectContentCommand = SelectObjectContentCommand;
+exports.ServerSideEncryption = ServerSideEncryption;
+exports.SessionMode = SessionMode;
+exports.SseKmsEncryptedObjectsStatus = SseKmsEncryptedObjectsStatus;
+exports.StorageClass = StorageClass;
+exports.StorageClassAnalysisSchemaVersion = StorageClassAnalysisSchemaVersion;
+exports.TableSseAlgorithm = TableSseAlgorithm;
+exports.TaggingDirective = TaggingDirective;
+exports.Tier = Tier;
+exports.TransitionDefaultMinimumObjectSize = TransitionDefaultMinimumObjectSize;
+exports.TransitionStorageClass = TransitionStorageClass;
+exports.Type = Type;
+exports.UpdateBucketMetadataInventoryTableConfigurationCommand = UpdateBucketMetadataInventoryTableConfigurationCommand;
+exports.UpdateBucketMetadataJournalTableConfigurationCommand = UpdateBucketMetadataJournalTableConfigurationCommand;
+exports.UpdateObjectEncryptionCommand = UpdateObjectEncryptionCommand;
+exports.UploadPartCommand = UploadPartCommand;
+exports.UploadPartCopyCommand = UploadPartCopyCommand;
+exports.WriteGetObjectResponseCommand = WriteGetObjectResponseCommand;
+exports.paginateListBuckets = paginateListBuckets;
+exports.paginateListDirectoryBuckets = paginateListDirectoryBuckets;
+exports.paginateListObjectsV2 = paginateListObjectsV2;
+exports.paginateListParts = paginateListParts;
+exports.waitForBucketExists = waitForBucketExists;
+exports.waitForBucketNotExists = waitForBucketNotExists;
+exports.waitForObjectExists = waitForObjectExists;
+exports.waitForObjectNotExists = waitForObjectNotExists;
+exports.waitUntilBucketExists = waitUntilBucketExists;
+exports.waitUntilBucketNotExists = waitUntilBucketNotExists;
+exports.waitUntilObjectExists = waitUntilObjectExists;
+exports.waitUntilObjectNotExists = waitUntilObjectNotExists;
+Object.prototype.hasOwnProperty.call(schemas_0, '__proto__') &&
+    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
+    Object.defineProperty(exports, '__proto__', {
+        enumerable: true,
+        value: schemas_0['__proto__']
+    });
+
+Object.keys(schemas_0).forEach(function (k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = schemas_0[k];
+});
+Object.prototype.hasOwnProperty.call(errors, '__proto__') &&
+    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
+    Object.defineProperty(exports, '__proto__', {
+        enumerable: true,
+        value: errors['__proto__']
+    });
+
+Object.keys(errors).forEach(function (k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = errors[k];
+});