@aws-sdk/client-cloudfront 3.183.0 → 3.186.0

package/dist-es/CloudFrontClient.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { resolveEndpointsConfig, resolveRegionConfig, } from "@aws-sdk/config-resolver";
 import { getContentLengthPlugin } from "@aws-sdk/middleware-content-length";
 import { getHostHeaderPlugin, resolveHostHeaderConfig, } from "@aws-sdk/middleware-host-header";
@@ -8,26 +9,31 @@ import { getAwsAuthPlugin, resolveAwsAuthConfig, } from "@aws-sdk/middleware-sig
 import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
 import { Client as __Client, } from "@aws-sdk/smithy-client";
 import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
-export class CloudFrontClient extends __Client {
-    constructor(configuration) {
-        const _config_0 = __getRuntimeConfig(configuration);
-        const _config_1 = resolveRegionConfig(_config_0);
-        const _config_2 = resolveEndpointsConfig(_config_1);
-        const _config_3 = resolveRetryConfig(_config_2);
-        const _config_4 = resolveHostHeaderConfig(_config_3);
-        const _config_5 = resolveAwsAuthConfig(_config_4);
-        const _config_6 = resolveUserAgentConfig(_config_5);
-        super(_config_6);
-        this.config = _config_6;
-        this.middlewareStack.use(getRetryPlugin(this.config));
-        this.middlewareStack.use(getContentLengthPlugin(this.config));
-        this.middlewareStack.use(getHostHeaderPlugin(this.config));
-        this.middlewareStack.use(getLoggerPlugin(this.config));
-        this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
-        this.middlewareStack.use(getAwsAuthPlugin(this.config));
-        this.middlewareStack.use(getUserAgentPlugin(this.config));
+var CloudFrontClient = (function (_super) {
+    __extends(CloudFrontClient, _super);
+    function CloudFrontClient(configuration) {
+        var _this = this;
+        var _config_0 = __getRuntimeConfig(configuration);
+        var _config_1 = resolveRegionConfig(_config_0);
+        var _config_2 = resolveEndpointsConfig(_config_1);
+        var _config_3 = resolveRetryConfig(_config_2);
+        var _config_4 = resolveHostHeaderConfig(_config_3);
+        var _config_5 = resolveAwsAuthConfig(_config_4);
+        var _config_6 = resolveUserAgentConfig(_config_5);
+        _this = _super.call(this, _config_6) || this;
+        _this.config = _config_6;
+        _this.middlewareStack.use(getRetryPlugin(_this.config));
+        _this.middlewareStack.use(getContentLengthPlugin(_this.config));
+        _this.middlewareStack.use(getHostHeaderPlugin(_this.config));
+        _this.middlewareStack.use(getLoggerPlugin(_this.config));
+        _this.middlewareStack.use(getRecursionDetectionPlugin(_this.config));
+        _this.middlewareStack.use(getAwsAuthPlugin(_this.config));
+        _this.middlewareStack.use(getUserAgentPlugin(_this.config));
+        return _this;
     }
-    destroy() {
-        super.destroy();
-    }
-}
+    CloudFrontClient.prototype.destroy = function () {
+        _super.prototype.destroy.call(this);
+    };
+    return CloudFrontClient;
+}(__Client));
+export { CloudFrontClient };

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

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

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

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

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

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

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

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

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