@aws-sdk/client-cloudfront 3.181.0 → 3.183.0

package/dist-es/CloudFrontClient.js

@@ -1,4 +1,3 @@
-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";
@@ -9,31 +8,26 @@ 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";
-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;
+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));
     }
-    CloudFrontClient.prototype.destroy = function () {
-        _super.prototype.destroy.call(this);
-    };
-    return CloudFrontClient;
-}(__Client));
-export { CloudFrontClient };
+    destroy() {
+        super.destroy();
+    }
+}

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

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

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

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

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

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

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

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

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