@aws-sdk/client-cloudfront 3.183.0 → 3.185.0

package/dist-es/commands/GetFieldLevelEncryptionCommand.js

@@ -1,32 +1,39 @@
+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";
-export class GetFieldLevelEncryptionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetFieldLevelEncryptionCommand = (function (_super) {
+    __extends(GetFieldLevelEncryptionCommand, _super);
+    function GetFieldLevelEncryptionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetFieldLevelEncryptionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CloudFrontClient";
-        const commandName = "GetFieldLevelEncryptionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "GetFieldLevelEncryptionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetFieldLevelEncryptionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetFieldLevelEncryptionResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetFieldLevelEncryptionCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlGetFieldLevelEncryptionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetFieldLevelEncryptionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlGetFieldLevelEncryptionCommand(output, context);
-    }
-}
+    };
+    return GetFieldLevelEncryptionCommand;
+}($Command));
+export { GetFieldLevelEncryptionCommand };

package/dist-es/commands/GetFieldLevelEncryptionConfigCommand.js

@@ -1,32 +1,39 @@
+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";
-export class GetFieldLevelEncryptionConfigCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetFieldLevelEncryptionConfigCommand = (function (_super) {
+    __extends(GetFieldLevelEncryptionConfigCommand, _super);
+    function GetFieldLevelEncryptionConfigCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetFieldLevelEncryptionConfigCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CloudFrontClient";
-        const commandName = "GetFieldLevelEncryptionConfigCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "GetFieldLevelEncryptionConfigCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetFieldLevelEncryptionConfigRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetFieldLevelEncryptionConfigResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetFieldLevelEncryptionConfigCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlGetFieldLevelEncryptionConfigCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetFieldLevelEncryptionConfigCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlGetFieldLevelEncryptionConfigCommand(output, context);
-    }
-}
+    };
+    return GetFieldLevelEncryptionConfigCommand;
+}($Command));
+export { GetFieldLevelEncryptionConfigCommand };

package/dist-es/commands/GetFieldLevelEncryptionProfileCommand.js

@@ -1,32 +1,39 @@
+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";
-export class GetFieldLevelEncryptionProfileCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetFieldLevelEncryptionProfileCommand = (function (_super) {
+    __extends(GetFieldLevelEncryptionProfileCommand, _super);
+    function GetFieldLevelEncryptionProfileCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetFieldLevelEncryptionProfileCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CloudFrontClient";
-        const commandName = "GetFieldLevelEncryptionProfileCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "GetFieldLevelEncryptionProfileCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetFieldLevelEncryptionProfileRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetFieldLevelEncryptionProfileResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetFieldLevelEncryptionProfileCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlGetFieldLevelEncryptionProfileCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetFieldLevelEncryptionProfileCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlGetFieldLevelEncryptionProfileCommand(output, context);
-    }
-}
+    };
+    return GetFieldLevelEncryptionProfileCommand;
+}($Command));
+export { GetFieldLevelEncryptionProfileCommand };

package/dist-es/commands/GetFieldLevelEncryptionProfileConfigCommand.js

@@ -1,32 +1,39 @@
+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";
-export class GetFieldLevelEncryptionProfileConfigCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetFieldLevelEncryptionProfileConfigCommand = (function (_super) {
+    __extends(GetFieldLevelEncryptionProfileConfigCommand, _super);
+    function GetFieldLevelEncryptionProfileConfigCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetFieldLevelEncryptionProfileConfigCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CloudFrontClient";
-        const commandName = "GetFieldLevelEncryptionProfileConfigCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "GetFieldLevelEncryptionProfileConfigCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetFieldLevelEncryptionProfileConfigRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetFieldLevelEncryptionProfileConfigResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetFieldLevelEncryptionProfileConfigCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlGetFieldLevelEncryptionProfileConfigCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetFieldLevelEncryptionProfileConfigCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlGetFieldLevelEncryptionProfileConfigCommand(output, context);
-    }
-}
+    };
+    return GetFieldLevelEncryptionProfileConfigCommand;
+}($Command));
+export { GetFieldLevelEncryptionProfileConfigCommand };

package/dist-es/commands/GetFunctionCommand.js

@@ -1,32 +1,39 @@
+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";
-export class GetFunctionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetFunctionCommand = (function (_super) {
+    __extends(GetFunctionCommand, _super);
+    function GetFunctionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetFunctionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CloudFrontClient";
-        const commandName = "GetFunctionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "GetFunctionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetFunctionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetFunctionResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetFunctionCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlGetFunctionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetFunctionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlGetFunctionCommand(output, context);
-    }
-}
+    };
+    return GetFunctionCommand;
+}($Command));
+export { GetFunctionCommand };

package/dist-es/commands/GetInvalidationCommand.js

@@ -1,32 +1,39 @@
+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";
-export class GetInvalidationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetInvalidationCommand = (function (_super) {
+    __extends(GetInvalidationCommand, _super);
+    function GetInvalidationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetInvalidationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CloudFrontClient";
-        const commandName = "GetInvalidationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "GetInvalidationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetInvalidationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetInvalidationResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetInvalidationCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlGetInvalidationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetInvalidationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlGetInvalidationCommand(output, context);
-    }
-}
+    };
+    return GetInvalidationCommand;
+}($Command));
+export { GetInvalidationCommand };

package/dist-es/commands/GetKeyGroupCommand.js

@@ -1,32 +1,39 @@
+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";
-export class GetKeyGroupCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetKeyGroupCommand = (function (_super) {
+    __extends(GetKeyGroupCommand, _super);
+    function GetKeyGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetKeyGroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CloudFrontClient";
-        const commandName = "GetKeyGroupCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "GetKeyGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetKeyGroupRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetKeyGroupResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetKeyGroupCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlGetKeyGroupCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetKeyGroupCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlGetKeyGroupCommand(output, context);
-    }
-}
+    };
+    return GetKeyGroupCommand;
+}($Command));
+export { GetKeyGroupCommand };

package/dist-es/commands/GetKeyGroupConfigCommand.js

@@ -1,32 +1,39 @@
+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";
-export class GetKeyGroupConfigCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetKeyGroupConfigCommand = (function (_super) {
+    __extends(GetKeyGroupConfigCommand, _super);
+    function GetKeyGroupConfigCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetKeyGroupConfigCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CloudFrontClient";
-        const commandName = "GetKeyGroupConfigCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "GetKeyGroupConfigCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetKeyGroupConfigRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetKeyGroupConfigResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetKeyGroupConfigCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlGetKeyGroupConfigCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetKeyGroupConfigCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlGetKeyGroupConfigCommand(output, context);
-    }
-}
+    };
+    return GetKeyGroupConfigCommand;
+}($Command));
+export { GetKeyGroupConfigCommand };

package/dist-es/commands/GetMonitoringSubscriptionCommand.js

@@ -1,32 +1,39 @@
+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";
-export class GetMonitoringSubscriptionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetMonitoringSubscriptionCommand = (function (_super) {
+    __extends(GetMonitoringSubscriptionCommand, _super);
+    function GetMonitoringSubscriptionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetMonitoringSubscriptionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CloudFrontClient";
-        const commandName = "GetMonitoringSubscriptionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "GetMonitoringSubscriptionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetMonitoringSubscriptionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetMonitoringSubscriptionResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetMonitoringSubscriptionCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlGetMonitoringSubscriptionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetMonitoringSubscriptionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlGetMonitoringSubscriptionCommand(output, context);
-    }
-}
+    };
+    return GetMonitoringSubscriptionCommand;
+}($Command));
+export { GetMonitoringSubscriptionCommand };

package/dist-es/commands/GetOriginAccessControlCommand.js

@@ -1,32 +1,39 @@
+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";
-export class GetOriginAccessControlCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetOriginAccessControlCommand = (function (_super) {
+    __extends(GetOriginAccessControlCommand, _super);
+    function GetOriginAccessControlCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetOriginAccessControlCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CloudFrontClient";
-        const commandName = "GetOriginAccessControlCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "GetOriginAccessControlCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetOriginAccessControlRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetOriginAccessControlResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetOriginAccessControlCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlGetOriginAccessControlCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetOriginAccessControlCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlGetOriginAccessControlCommand(output, context);
-    }
-}
+    };
+    return GetOriginAccessControlCommand;
+}($Command));
+export { GetOriginAccessControlCommand };