@aws-sdk/client-cloudfront 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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