@aws-sdk/client-cloudfront 3.186.0 → 3.188.0

package/dist-es/commands/GetFieldLevelEncryptionCommand.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 { GetFieldLevelEncryptionRequestFilterSensitiveLog, GetFieldLevelEncryptionResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restXmlGetFieldLevelEncryptionCommand, serializeAws_restXmlGetFieldLevelEncryptionCommand, } from "../protocols/Aws_restXml";
-var GetFieldLevelEncryptionCommand = (function (_super) {
-    __extends(GetFieldLevelEncryptionCommand, _super);
-    function GetFieldLevelEncryptionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetFieldLevelEncryptionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetFieldLevelEncryptionCommand.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 = "GetFieldLevelEncryptionCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "GetFieldLevelEncryptionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetFieldLevelEncryptionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetFieldLevelEncryptionResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetFieldLevelEncryptionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlGetFieldLevelEncryptionCommand(input, context);
-    };
-    GetFieldLevelEncryptionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlGetFieldLevelEncryptionCommand(output, context);
-    };
-    return GetFieldLevelEncryptionCommand;
-}($Command));
-export { GetFieldLevelEncryptionCommand };
+    }
+}

package/dist-es/commands/GetFieldLevelEncryptionConfigCommand.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 { GetFieldLevelEncryptionConfigRequestFilterSensitiveLog, GetFieldLevelEncryptionConfigResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restXmlGetFieldLevelEncryptionConfigCommand, serializeAws_restXmlGetFieldLevelEncryptionConfigCommand, } from "../protocols/Aws_restXml";
-var GetFieldLevelEncryptionConfigCommand = (function (_super) {
-    __extends(GetFieldLevelEncryptionConfigCommand, _super);
-    function GetFieldLevelEncryptionConfigCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetFieldLevelEncryptionConfigCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetFieldLevelEncryptionConfigCommand.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 = "GetFieldLevelEncryptionConfigCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "GetFieldLevelEncryptionConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetFieldLevelEncryptionConfigRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetFieldLevelEncryptionConfigResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetFieldLevelEncryptionConfigCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlGetFieldLevelEncryptionConfigCommand(input, context);
-    };
-    GetFieldLevelEncryptionConfigCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlGetFieldLevelEncryptionConfigCommand(output, context);
-    };
-    return GetFieldLevelEncryptionConfigCommand;
-}($Command));
-export { GetFieldLevelEncryptionConfigCommand };
+    }
+}

package/dist-es/commands/GetFieldLevelEncryptionProfileCommand.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 { GetFieldLevelEncryptionProfileRequestFilterSensitiveLog, GetFieldLevelEncryptionProfileResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restXmlGetFieldLevelEncryptionProfileCommand, serializeAws_restXmlGetFieldLevelEncryptionProfileCommand, } from "../protocols/Aws_restXml";
-var GetFieldLevelEncryptionProfileCommand = (function (_super) {
-    __extends(GetFieldLevelEncryptionProfileCommand, _super);
-    function GetFieldLevelEncryptionProfileCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetFieldLevelEncryptionProfileCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetFieldLevelEncryptionProfileCommand.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 = "GetFieldLevelEncryptionProfileCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "GetFieldLevelEncryptionProfileCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetFieldLevelEncryptionProfileRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetFieldLevelEncryptionProfileResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetFieldLevelEncryptionProfileCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlGetFieldLevelEncryptionProfileCommand(input, context);
-    };
-    GetFieldLevelEncryptionProfileCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlGetFieldLevelEncryptionProfileCommand(output, context);
-    };
-    return GetFieldLevelEncryptionProfileCommand;
-}($Command));
-export { GetFieldLevelEncryptionProfileCommand };
+    }
+}

package/dist-es/commands/GetFieldLevelEncryptionProfileConfigCommand.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 { GetFieldLevelEncryptionProfileConfigRequestFilterSensitiveLog, GetFieldLevelEncryptionProfileConfigResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restXmlGetFieldLevelEncryptionProfileConfigCommand, serializeAws_restXmlGetFieldLevelEncryptionProfileConfigCommand, } from "../protocols/Aws_restXml";
-var GetFieldLevelEncryptionProfileConfigCommand = (function (_super) {
-    __extends(GetFieldLevelEncryptionProfileConfigCommand, _super);
-    function GetFieldLevelEncryptionProfileConfigCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetFieldLevelEncryptionProfileConfigCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetFieldLevelEncryptionProfileConfigCommand.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 = "GetFieldLevelEncryptionProfileConfigCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "GetFieldLevelEncryptionProfileConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetFieldLevelEncryptionProfileConfigRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetFieldLevelEncryptionProfileConfigResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetFieldLevelEncryptionProfileConfigCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlGetFieldLevelEncryptionProfileConfigCommand(input, context);
-    };
-    GetFieldLevelEncryptionProfileConfigCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlGetFieldLevelEncryptionProfileConfigCommand(output, context);
-    };
-    return GetFieldLevelEncryptionProfileConfigCommand;
-}($Command));
-export { GetFieldLevelEncryptionProfileConfigCommand };
+    }
+}

package/dist-es/commands/GetFunctionCommand.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 { GetFunctionRequestFilterSensitiveLog, GetFunctionResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restXmlGetFunctionCommand, serializeAws_restXmlGetFunctionCommand, } from "../protocols/Aws_restXml";
-var GetFunctionCommand = (function (_super) {
-    __extends(GetFunctionCommand, _super);
-    function GetFunctionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetFunctionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetFunctionCommand.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 = "GetFunctionCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "GetFunctionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetFunctionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetFunctionResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetFunctionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlGetFunctionCommand(input, context);
-    };
-    GetFunctionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlGetFunctionCommand(output, context);
-    };
-    return GetFunctionCommand;
-}($Command));
-export { GetFunctionCommand };
+    }
+}

package/dist-es/commands/GetInvalidationCommand.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 { GetInvalidationRequestFilterSensitiveLog, GetInvalidationResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restXmlGetInvalidationCommand, serializeAws_restXmlGetInvalidationCommand, } from "../protocols/Aws_restXml";
-var GetInvalidationCommand = (function (_super) {
-    __extends(GetInvalidationCommand, _super);
-    function GetInvalidationCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetInvalidationCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetInvalidationCommand.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 = "GetInvalidationCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "GetInvalidationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetInvalidationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetInvalidationResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetInvalidationCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlGetInvalidationCommand(input, context);
-    };
-    GetInvalidationCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlGetInvalidationCommand(output, context);
-    };
-    return GetInvalidationCommand;
-}($Command));
-export { GetInvalidationCommand };
+    }
+}

package/dist-es/commands/GetKeyGroupCommand.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 { GetKeyGroupRequestFilterSensitiveLog, GetKeyGroupResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restXmlGetKeyGroupCommand, serializeAws_restXmlGetKeyGroupCommand, } from "../protocols/Aws_restXml";
-var GetKeyGroupCommand = (function (_super) {
-    __extends(GetKeyGroupCommand, _super);
-    function GetKeyGroupCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetKeyGroupCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetKeyGroupCommand.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 = "GetKeyGroupCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "GetKeyGroupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetKeyGroupRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetKeyGroupResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetKeyGroupCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlGetKeyGroupCommand(input, context);
-    };
-    GetKeyGroupCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlGetKeyGroupCommand(output, context);
-    };
-    return GetKeyGroupCommand;
-}($Command));
-export { GetKeyGroupCommand };
+    }
+}

package/dist-es/commands/GetKeyGroupConfigCommand.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 { GetKeyGroupConfigRequestFilterSensitiveLog, GetKeyGroupConfigResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restXmlGetKeyGroupConfigCommand, serializeAws_restXmlGetKeyGroupConfigCommand, } from "../protocols/Aws_restXml";
-var GetKeyGroupConfigCommand = (function (_super) {
-    __extends(GetKeyGroupConfigCommand, _super);
-    function GetKeyGroupConfigCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetKeyGroupConfigCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetKeyGroupConfigCommand.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 = "GetKeyGroupConfigCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "GetKeyGroupConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetKeyGroupConfigRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetKeyGroupConfigResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetKeyGroupConfigCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlGetKeyGroupConfigCommand(input, context);
-    };
-    GetKeyGroupConfigCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlGetKeyGroupConfigCommand(output, context);
-    };
-    return GetKeyGroupConfigCommand;
-}($Command));
-export { GetKeyGroupConfigCommand };
+    }
+}

package/dist-es/commands/GetMonitoringSubscriptionCommand.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 { GetMonitoringSubscriptionRequestFilterSensitiveLog, GetMonitoringSubscriptionResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restXmlGetMonitoringSubscriptionCommand, serializeAws_restXmlGetMonitoringSubscriptionCommand, } from "../protocols/Aws_restXml";
-var GetMonitoringSubscriptionCommand = (function (_super) {
-    __extends(GetMonitoringSubscriptionCommand, _super);
-    function GetMonitoringSubscriptionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetMonitoringSubscriptionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetMonitoringSubscriptionCommand.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 = "GetMonitoringSubscriptionCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "GetMonitoringSubscriptionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetMonitoringSubscriptionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetMonitoringSubscriptionResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetMonitoringSubscriptionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlGetMonitoringSubscriptionCommand(input, context);
-    };
-    GetMonitoringSubscriptionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlGetMonitoringSubscriptionCommand(output, context);
-    };
-    return GetMonitoringSubscriptionCommand;
-}($Command));
-export { GetMonitoringSubscriptionCommand };
+    }
+}

package/dist-es/commands/GetOriginAccessControlCommand.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 { GetOriginAccessControlRequestFilterSensitiveLog, GetOriginAccessControlResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restXmlGetOriginAccessControlCommand, serializeAws_restXmlGetOriginAccessControlCommand, } from "../protocols/Aws_restXml";
-var GetOriginAccessControlCommand = (function (_super) {
-    __extends(GetOriginAccessControlCommand, _super);
-    function GetOriginAccessControlCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetOriginAccessControlCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetOriginAccessControlCommand.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 = "GetOriginAccessControlCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "GetOriginAccessControlCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetOriginAccessControlRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetOriginAccessControlResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetOriginAccessControlCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlGetOriginAccessControlCommand(input, context);
-    };
-    GetOriginAccessControlCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlGetOriginAccessControlCommand(output, context);
-    };
-    return GetOriginAccessControlCommand;
-}($Command));
-export { GetOriginAccessControlCommand };
+    }
+}