@aws-sdk/client-cloudfront 3.180.0 → 3.183.0

package/dist-es/commands/ListStreamingDistributionsCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListStreamingDistributionsRequestFilterSensitiveLog, ListStreamingDistributionsResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restXmlListStreamingDistributionsCommand, serializeAws_restXmlListStreamingDistributionsCommand, } from "../protocols/Aws_restXml";
-var ListStreamingDistributionsCommand = (function (_super) {
-    __extends(ListStreamingDistributionsCommand, _super);
-    function ListStreamingDistributionsCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class ListStreamingDistributionsCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    ListStreamingDistributionsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "CloudFrontClient";
-        var commandName = "ListStreamingDistributionsCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "ListStreamingDistributionsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: ListStreamingDistributionsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListStreamingDistributionsResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    ListStreamingDistributionsCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlListStreamingDistributionsCommand(input, context);
-    };
-    ListStreamingDistributionsCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlListStreamingDistributionsCommand(output, context);
-    };
-    return ListStreamingDistributionsCommand;
-}($Command));
-export { ListStreamingDistributionsCommand };
+    }
+}

package/dist-es/commands/ListTagsForResourceCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListTagsForResourceRequestFilterSensitiveLog, ListTagsForResourceResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restXmlListTagsForResourceCommand, serializeAws_restXmlListTagsForResourceCommand, } from "../protocols/Aws_restXml";
-var ListTagsForResourceCommand = (function (_super) {
-    __extends(ListTagsForResourceCommand, _super);
-    function ListTagsForResourceCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class ListTagsForResourceCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    ListTagsForResourceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "CloudFrontClient";
-        var commandName = "ListTagsForResourceCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "ListTagsForResourceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: ListTagsForResourceRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListTagsForResourceResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    ListTagsForResourceCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlListTagsForResourceCommand(input, context);
-    };
-    ListTagsForResourceCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlListTagsForResourceCommand(output, context);
-    };
-    return ListTagsForResourceCommand;
-}($Command));
-export { ListTagsForResourceCommand };
+    }
+}

package/dist-es/commands/PublishFunctionCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { PublishFunctionRequestFilterSensitiveLog, PublishFunctionResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restXmlPublishFunctionCommand, serializeAws_restXmlPublishFunctionCommand, } from "../protocols/Aws_restXml";
-var PublishFunctionCommand = (function (_super) {
-    __extends(PublishFunctionCommand, _super);
-    function PublishFunctionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class PublishFunctionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    PublishFunctionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "CloudFrontClient";
-        var commandName = "PublishFunctionCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "PublishFunctionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: PublishFunctionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: PublishFunctionResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    PublishFunctionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlPublishFunctionCommand(input, context);
-    };
-    PublishFunctionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlPublishFunctionCommand(output, context);
-    };
-    return PublishFunctionCommand;
-}($Command));
-export { PublishFunctionCommand };
+    }
+}

package/dist-es/commands/TagResourceCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { TagResourceRequestFilterSensitiveLog } from "../models/models_1";
 import { deserializeAws_restXmlTagResourceCommand, serializeAws_restXmlTagResourceCommand, } from "../protocols/Aws_restXml";
-var TagResourceCommand = (function (_super) {
-    __extends(TagResourceCommand, _super);
-    function TagResourceCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class TagResourceCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    TagResourceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "CloudFrontClient";
-        var commandName = "TagResourceCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "TagResourceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: TagResourceRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: function (output) { return output; },
+            outputFilterSensitiveLog: (output) => output,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    TagResourceCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlTagResourceCommand(input, context);
-    };
-    TagResourceCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlTagResourceCommand(output, context);
-    };
-    return TagResourceCommand;
-}($Command));
-export { TagResourceCommand };
+    }
+}

package/dist-es/commands/TestFunctionCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { TestFunctionRequestFilterSensitiveLog, TestFunctionResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restXmlTestFunctionCommand, serializeAws_restXmlTestFunctionCommand, } from "../protocols/Aws_restXml";
-var TestFunctionCommand = (function (_super) {
-    __extends(TestFunctionCommand, _super);
-    function TestFunctionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class TestFunctionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    TestFunctionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "CloudFrontClient";
-        var commandName = "TestFunctionCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "TestFunctionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: TestFunctionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: TestFunctionResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    TestFunctionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlTestFunctionCommand(input, context);
-    };
-    TestFunctionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlTestFunctionCommand(output, context);
-    };
-    return TestFunctionCommand;
-}($Command));
-export { TestFunctionCommand };
+    }
+}

package/dist-es/commands/UntagResourceCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { UntagResourceRequestFilterSensitiveLog } from "../models/models_1";
 import { deserializeAws_restXmlUntagResourceCommand, serializeAws_restXmlUntagResourceCommand, } from "../protocols/Aws_restXml";
-var UntagResourceCommand = (function (_super) {
-    __extends(UntagResourceCommand, _super);
-    function UntagResourceCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class UntagResourceCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    UntagResourceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "CloudFrontClient";
-        var commandName = "UntagResourceCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "UntagResourceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: UntagResourceRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: function (output) { return output; },
+            outputFilterSensitiveLog: (output) => output,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    UntagResourceCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlUntagResourceCommand(input, context);
-    };
-    UntagResourceCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlUntagResourceCommand(output, context);
-    };
-    return UntagResourceCommand;
-}($Command));
-export { UntagResourceCommand };
+    }
+}

package/dist-es/commands/UpdateCachePolicyCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { UpdateCachePolicyRequestFilterSensitiveLog, UpdateCachePolicyResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restXmlUpdateCachePolicyCommand, serializeAws_restXmlUpdateCachePolicyCommand, } from "../protocols/Aws_restXml";
-var UpdateCachePolicyCommand = (function (_super) {
-    __extends(UpdateCachePolicyCommand, _super);
-    function UpdateCachePolicyCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class UpdateCachePolicyCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    UpdateCachePolicyCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "CloudFrontClient";
-        var commandName = "UpdateCachePolicyCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "UpdateCachePolicyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: UpdateCachePolicyRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateCachePolicyResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    UpdateCachePolicyCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlUpdateCachePolicyCommand(input, context);
-    };
-    UpdateCachePolicyCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlUpdateCachePolicyCommand(output, context);
-    };
-    return UpdateCachePolicyCommand;
-}($Command));
-export { UpdateCachePolicyCommand };
+    }
+}

package/dist-es/commands/UpdateCloudFrontOriginAccessIdentityCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { UpdateCloudFrontOriginAccessIdentityRequestFilterSensitiveLog, UpdateCloudFrontOriginAccessIdentityResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restXmlUpdateCloudFrontOriginAccessIdentityCommand, serializeAws_restXmlUpdateCloudFrontOriginAccessIdentityCommand, } from "../protocols/Aws_restXml";
-var UpdateCloudFrontOriginAccessIdentityCommand = (function (_super) {
-    __extends(UpdateCloudFrontOriginAccessIdentityCommand, _super);
-    function UpdateCloudFrontOriginAccessIdentityCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class UpdateCloudFrontOriginAccessIdentityCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    UpdateCloudFrontOriginAccessIdentityCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "CloudFrontClient";
-        var commandName = "UpdateCloudFrontOriginAccessIdentityCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "UpdateCloudFrontOriginAccessIdentityCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: UpdateCloudFrontOriginAccessIdentityRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateCloudFrontOriginAccessIdentityResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    UpdateCloudFrontOriginAccessIdentityCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlUpdateCloudFrontOriginAccessIdentityCommand(input, context);
-    };
-    UpdateCloudFrontOriginAccessIdentityCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlUpdateCloudFrontOriginAccessIdentityCommand(output, context);
-    };
-    return UpdateCloudFrontOriginAccessIdentityCommand;
-}($Command));
-export { UpdateCloudFrontOriginAccessIdentityCommand };
+    }
+}

package/dist-es/commands/UpdateDistributionCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { UpdateDistributionRequestFilterSensitiveLog, UpdateDistributionResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restXmlUpdateDistributionCommand, serializeAws_restXmlUpdateDistributionCommand, } from "../protocols/Aws_restXml";
-var UpdateDistributionCommand = (function (_super) {
-    __extends(UpdateDistributionCommand, _super);
-    function UpdateDistributionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class UpdateDistributionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    UpdateDistributionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "CloudFrontClient";
-        var commandName = "UpdateDistributionCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "UpdateDistributionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: UpdateDistributionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateDistributionResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    UpdateDistributionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlUpdateDistributionCommand(input, context);
-    };
-    UpdateDistributionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlUpdateDistributionCommand(output, context);
-    };
-    return UpdateDistributionCommand;
-}($Command));
-export { UpdateDistributionCommand };
+    }
+}

package/dist-es/commands/UpdateFieldLevelEncryptionConfigCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { UpdateFieldLevelEncryptionConfigRequestFilterSensitiveLog, UpdateFieldLevelEncryptionConfigResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restXmlUpdateFieldLevelEncryptionConfigCommand, serializeAws_restXmlUpdateFieldLevelEncryptionConfigCommand, } from "../protocols/Aws_restXml";
-var UpdateFieldLevelEncryptionConfigCommand = (function (_super) {
-    __extends(UpdateFieldLevelEncryptionConfigCommand, _super);
-    function UpdateFieldLevelEncryptionConfigCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class UpdateFieldLevelEncryptionConfigCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    UpdateFieldLevelEncryptionConfigCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "CloudFrontClient";
-        var commandName = "UpdateFieldLevelEncryptionConfigCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "UpdateFieldLevelEncryptionConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: UpdateFieldLevelEncryptionConfigRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateFieldLevelEncryptionConfigResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    UpdateFieldLevelEncryptionConfigCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlUpdateFieldLevelEncryptionConfigCommand(input, context);
-    };
-    UpdateFieldLevelEncryptionConfigCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlUpdateFieldLevelEncryptionConfigCommand(output, context);
-    };
-    return UpdateFieldLevelEncryptionConfigCommand;
-}($Command));
-export { UpdateFieldLevelEncryptionConfigCommand };
+    }
+}