@aws-sdk/client-cloudfront 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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