@aws-sdk/client-cloudfront 3.183.0 → 3.186.0

package/dist-es/commands/CreateKeyGroupCommand.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 { CreateKeyGroupRequestFilterSensitiveLog, CreateKeyGroupResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlCreateKeyGroupCommand, serializeAws_restXmlCreateKeyGroupCommand, } from "../protocols/Aws_restXml";
-export class CreateKeyGroupCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateKeyGroupCommand = (function (_super) {
+    __extends(CreateKeyGroupCommand, _super);
+    function CreateKeyGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateKeyGroupCommand.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 = "CreateKeyGroupCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "CreateKeyGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateKeyGroupRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateKeyGroupResultFilterSensitiveLog,
         };
-        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);
+    };
+    CreateKeyGroupCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlCreateKeyGroupCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateKeyGroupCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlCreateKeyGroupCommand(output, context);
-    }
-}
+    };
+    return CreateKeyGroupCommand;
+}($Command));
+export { CreateKeyGroupCommand };

package/dist-es/commands/CreateMonitoringSubscriptionCommand.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 { CreateMonitoringSubscriptionRequestFilterSensitiveLog, CreateMonitoringSubscriptionResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlCreateMonitoringSubscriptionCommand, serializeAws_restXmlCreateMonitoringSubscriptionCommand, } from "../protocols/Aws_restXml";
-export class CreateMonitoringSubscriptionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateMonitoringSubscriptionCommand = (function (_super) {
+    __extends(CreateMonitoringSubscriptionCommand, _super);
+    function CreateMonitoringSubscriptionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateMonitoringSubscriptionCommand.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 = "CreateMonitoringSubscriptionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "CreateMonitoringSubscriptionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateMonitoringSubscriptionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateMonitoringSubscriptionResultFilterSensitiveLog,
         };
-        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);
+    };
+    CreateMonitoringSubscriptionCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlCreateMonitoringSubscriptionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateMonitoringSubscriptionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlCreateMonitoringSubscriptionCommand(output, context);
-    }
-}
+    };
+    return CreateMonitoringSubscriptionCommand;
+}($Command));
+export { CreateMonitoringSubscriptionCommand };

package/dist-es/commands/CreateOriginAccessControlCommand.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 { CreateOriginAccessControlRequestFilterSensitiveLog, CreateOriginAccessControlResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlCreateOriginAccessControlCommand, serializeAws_restXmlCreateOriginAccessControlCommand, } from "../protocols/Aws_restXml";
-export class CreateOriginAccessControlCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateOriginAccessControlCommand = (function (_super) {
+    __extends(CreateOriginAccessControlCommand, _super);
+    function CreateOriginAccessControlCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateOriginAccessControlCommand.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 = "CreateOriginAccessControlCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "CreateOriginAccessControlCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateOriginAccessControlRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateOriginAccessControlResultFilterSensitiveLog,
         };
-        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);
+    };
+    CreateOriginAccessControlCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlCreateOriginAccessControlCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateOriginAccessControlCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlCreateOriginAccessControlCommand(output, context);
-    }
-}
+    };
+    return CreateOriginAccessControlCommand;
+}($Command));
+export { CreateOriginAccessControlCommand };

package/dist-es/commands/CreateOriginRequestPolicyCommand.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 { CreateOriginRequestPolicyRequestFilterSensitiveLog, CreateOriginRequestPolicyResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlCreateOriginRequestPolicyCommand, serializeAws_restXmlCreateOriginRequestPolicyCommand, } from "../protocols/Aws_restXml";
-export class CreateOriginRequestPolicyCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateOriginRequestPolicyCommand = (function (_super) {
+    __extends(CreateOriginRequestPolicyCommand, _super);
+    function CreateOriginRequestPolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateOriginRequestPolicyCommand.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 = "CreateOriginRequestPolicyCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "CreateOriginRequestPolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateOriginRequestPolicyRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateOriginRequestPolicyResultFilterSensitiveLog,
         };
-        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);
+    };
+    CreateOriginRequestPolicyCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlCreateOriginRequestPolicyCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateOriginRequestPolicyCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlCreateOriginRequestPolicyCommand(output, context);
-    }
-}
+    };
+    return CreateOriginRequestPolicyCommand;
+}($Command));
+export { CreateOriginRequestPolicyCommand };

package/dist-es/commands/CreatePublicKeyCommand.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 { CreatePublicKeyRequestFilterSensitiveLog, CreatePublicKeyResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlCreatePublicKeyCommand, serializeAws_restXmlCreatePublicKeyCommand, } from "../protocols/Aws_restXml";
-export class CreatePublicKeyCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreatePublicKeyCommand = (function (_super) {
+    __extends(CreatePublicKeyCommand, _super);
+    function CreatePublicKeyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreatePublicKeyCommand.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 = "CreatePublicKeyCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "CreatePublicKeyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreatePublicKeyRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreatePublicKeyResultFilterSensitiveLog,
         };
-        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);
+    };
+    CreatePublicKeyCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlCreatePublicKeyCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreatePublicKeyCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlCreatePublicKeyCommand(output, context);
-    }
-}
+    };
+    return CreatePublicKeyCommand;
+}($Command));
+export { CreatePublicKeyCommand };

package/dist-es/commands/CreateRealtimeLogConfigCommand.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 { CreateRealtimeLogConfigRequestFilterSensitiveLog, CreateRealtimeLogConfigResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlCreateRealtimeLogConfigCommand, serializeAws_restXmlCreateRealtimeLogConfigCommand, } from "../protocols/Aws_restXml";
-export class CreateRealtimeLogConfigCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateRealtimeLogConfigCommand = (function (_super) {
+    __extends(CreateRealtimeLogConfigCommand, _super);
+    function CreateRealtimeLogConfigCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateRealtimeLogConfigCommand.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 = "CreateRealtimeLogConfigCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "CreateRealtimeLogConfigCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateRealtimeLogConfigRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateRealtimeLogConfigResultFilterSensitiveLog,
         };
-        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);
+    };
+    CreateRealtimeLogConfigCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlCreateRealtimeLogConfigCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateRealtimeLogConfigCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlCreateRealtimeLogConfigCommand(output, context);
-    }
-}
+    };
+    return CreateRealtimeLogConfigCommand;
+}($Command));
+export { CreateRealtimeLogConfigCommand };

package/dist-es/commands/CreateResponseHeadersPolicyCommand.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 { CreateResponseHeadersPolicyRequestFilterSensitiveLog, CreateResponseHeadersPolicyResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlCreateResponseHeadersPolicyCommand, serializeAws_restXmlCreateResponseHeadersPolicyCommand, } from "../protocols/Aws_restXml";
-export class CreateResponseHeadersPolicyCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateResponseHeadersPolicyCommand = (function (_super) {
+    __extends(CreateResponseHeadersPolicyCommand, _super);
+    function CreateResponseHeadersPolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateResponseHeadersPolicyCommand.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 = "CreateResponseHeadersPolicyCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "CreateResponseHeadersPolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateResponseHeadersPolicyRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateResponseHeadersPolicyResultFilterSensitiveLog,
         };
-        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);
+    };
+    CreateResponseHeadersPolicyCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlCreateResponseHeadersPolicyCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateResponseHeadersPolicyCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlCreateResponseHeadersPolicyCommand(output, context);
-    }
-}
+    };
+    return CreateResponseHeadersPolicyCommand;
+}($Command));
+export { CreateResponseHeadersPolicyCommand };

package/dist-es/commands/CreateStreamingDistributionCommand.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 { CreateStreamingDistributionRequestFilterSensitiveLog, CreateStreamingDistributionResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlCreateStreamingDistributionCommand, serializeAws_restXmlCreateStreamingDistributionCommand, } from "../protocols/Aws_restXml";
-export class CreateStreamingDistributionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateStreamingDistributionCommand = (function (_super) {
+    __extends(CreateStreamingDistributionCommand, _super);
+    function CreateStreamingDistributionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateStreamingDistributionCommand.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 = "CreateStreamingDistributionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "CreateStreamingDistributionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateStreamingDistributionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateStreamingDistributionResultFilterSensitiveLog,
         };
-        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);
+    };
+    CreateStreamingDistributionCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlCreateStreamingDistributionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateStreamingDistributionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlCreateStreamingDistributionCommand(output, context);
-    }
-}
+    };
+    return CreateStreamingDistributionCommand;
+}($Command));
+export { CreateStreamingDistributionCommand };

package/dist-es/commands/CreateStreamingDistributionWithTagsCommand.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 { CreateStreamingDistributionWithTagsRequestFilterSensitiveLog, CreateStreamingDistributionWithTagsResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlCreateStreamingDistributionWithTagsCommand, serializeAws_restXmlCreateStreamingDistributionWithTagsCommand, } from "../protocols/Aws_restXml";
-export class CreateStreamingDistributionWithTagsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateStreamingDistributionWithTagsCommand = (function (_super) {
+    __extends(CreateStreamingDistributionWithTagsCommand, _super);
+    function CreateStreamingDistributionWithTagsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateStreamingDistributionWithTagsCommand.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 = "CreateStreamingDistributionWithTagsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudFrontClient";
+        var commandName = "CreateStreamingDistributionWithTagsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateStreamingDistributionWithTagsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateStreamingDistributionWithTagsResultFilterSensitiveLog,
         };
-        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);
+    };
+    CreateStreamingDistributionWithTagsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlCreateStreamingDistributionWithTagsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateStreamingDistributionWithTagsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlCreateStreamingDistributionWithTagsCommand(output, context);
-    }
-}
+    };
+    return CreateStreamingDistributionWithTagsCommand;
+}($Command));
+export { CreateStreamingDistributionWithTagsCommand };

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