@aws-sdk/client-cloudfront 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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