@aws-sdk/client-cloudfront 3.180.0 → 3.183.0

package/dist-es/commands/ListCachePoliciesCommand.js

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

package/dist-es/commands/ListCloudFrontOriginAccessIdentitiesCommand.js

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

package/dist-es/commands/ListConflictingAliasesCommand.js

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

package/dist-es/commands/ListDistributionsByCachePolicyIdCommand.js

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

package/dist-es/commands/ListDistributionsByKeyGroupCommand.js

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

package/dist-es/commands/ListDistributionsByOriginRequestPolicyIdCommand.js

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

package/dist-es/commands/ListDistributionsByRealtimeLogConfigCommand.js

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

package/dist-es/commands/ListDistributionsByResponseHeadersPolicyIdCommand.js

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

package/dist-es/commands/ListDistributionsByWebACLIdCommand.js

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

package/dist-es/commands/ListDistributionsCommand.js

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