@aws-sdk/client-cloudfront 3.181.0 → 3.183.0

package/dist-es/CloudFront.js

@@ -1,4 +1,3 @@
-import { __extends } from "tslib";
 import { CloudFrontClient } from "./CloudFrontClient";
 import { AssociateAliasCommand, } from "./commands/AssociateAliasCommand";
 import { CreateCachePolicyCommand, } from "./commands/CreateCachePolicyCommand";
@@ -98,1383 +97,1377 @@ import { UpdatePublicKeyCommand, } from "./commands/UpdatePublicKeyCommand";
 import { UpdateRealtimeLogConfigCommand, } from "./commands/UpdateRealtimeLogConfigCommand";
 import { UpdateResponseHeadersPolicyCommand, } from "./commands/UpdateResponseHeadersPolicyCommand";
 import { UpdateStreamingDistributionCommand, } from "./commands/UpdateStreamingDistributionCommand";
-var CloudFront = (function (_super) {
-    __extends(CloudFront, _super);
-    function CloudFront() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    CloudFront.prototype.associateAlias = function (args, optionsOrCb, cb) {
-        var command = new AssociateAliasCommand(args);
+export class CloudFront extends CloudFrontClient {
+    associateAlias(args, optionsOrCb, cb) {
+        const command = new AssociateAliasCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.createCachePolicy = function (args, optionsOrCb, cb) {
-        var command = new CreateCachePolicyCommand(args);
+    }
+    createCachePolicy(args, optionsOrCb, cb) {
+        const command = new CreateCachePolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.createCloudFrontOriginAccessIdentity = function (args, optionsOrCb, cb) {
-        var command = new CreateCloudFrontOriginAccessIdentityCommand(args);
+    }
+    createCloudFrontOriginAccessIdentity(args, optionsOrCb, cb) {
+        const command = new CreateCloudFrontOriginAccessIdentityCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.createDistribution = function (args, optionsOrCb, cb) {
-        var command = new CreateDistributionCommand(args);
+    }
+    createDistribution(args, optionsOrCb, cb) {
+        const command = new CreateDistributionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.createDistributionWithTags = function (args, optionsOrCb, cb) {
-        var command = new CreateDistributionWithTagsCommand(args);
+    }
+    createDistributionWithTags(args, optionsOrCb, cb) {
+        const command = new CreateDistributionWithTagsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.createFieldLevelEncryptionConfig = function (args, optionsOrCb, cb) {
-        var command = new CreateFieldLevelEncryptionConfigCommand(args);
+    }
+    createFieldLevelEncryptionConfig(args, optionsOrCb, cb) {
+        const command = new CreateFieldLevelEncryptionConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.createFieldLevelEncryptionProfile = function (args, optionsOrCb, cb) {
-        var command = new CreateFieldLevelEncryptionProfileCommand(args);
+    }
+    createFieldLevelEncryptionProfile(args, optionsOrCb, cb) {
+        const command = new CreateFieldLevelEncryptionProfileCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.createFunction = function (args, optionsOrCb, cb) {
-        var command = new CreateFunctionCommand(args);
+    }
+    createFunction(args, optionsOrCb, cb) {
+        const command = new CreateFunctionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.createInvalidation = function (args, optionsOrCb, cb) {
-        var command = new CreateInvalidationCommand(args);
+    }
+    createInvalidation(args, optionsOrCb, cb) {
+        const command = new CreateInvalidationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.createKeyGroup = function (args, optionsOrCb, cb) {
-        var command = new CreateKeyGroupCommand(args);
+    }
+    createKeyGroup(args, optionsOrCb, cb) {
+        const command = new CreateKeyGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.createMonitoringSubscription = function (args, optionsOrCb, cb) {
-        var command = new CreateMonitoringSubscriptionCommand(args);
+    }
+    createMonitoringSubscription(args, optionsOrCb, cb) {
+        const command = new CreateMonitoringSubscriptionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.createOriginAccessControl = function (args, optionsOrCb, cb) {
-        var command = new CreateOriginAccessControlCommand(args);
+    }
+    createOriginAccessControl(args, optionsOrCb, cb) {
+        const command = new CreateOriginAccessControlCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.createOriginRequestPolicy = function (args, optionsOrCb, cb) {
-        var command = new CreateOriginRequestPolicyCommand(args);
+    }
+    createOriginRequestPolicy(args, optionsOrCb, cb) {
+        const command = new CreateOriginRequestPolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.createPublicKey = function (args, optionsOrCb, cb) {
-        var command = new CreatePublicKeyCommand(args);
+    }
+    createPublicKey(args, optionsOrCb, cb) {
+        const command = new CreatePublicKeyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.createRealtimeLogConfig = function (args, optionsOrCb, cb) {
-        var command = new CreateRealtimeLogConfigCommand(args);
+    }
+    createRealtimeLogConfig(args, optionsOrCb, cb) {
+        const command = new CreateRealtimeLogConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.createResponseHeadersPolicy = function (args, optionsOrCb, cb) {
-        var command = new CreateResponseHeadersPolicyCommand(args);
+    }
+    createResponseHeadersPolicy(args, optionsOrCb, cb) {
+        const command = new CreateResponseHeadersPolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.createStreamingDistribution = function (args, optionsOrCb, cb) {
-        var command = new CreateStreamingDistributionCommand(args);
+    }
+    createStreamingDistribution(args, optionsOrCb, cb) {
+        const command = new CreateStreamingDistributionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.createStreamingDistributionWithTags = function (args, optionsOrCb, cb) {
-        var command = new CreateStreamingDistributionWithTagsCommand(args);
+    }
+    createStreamingDistributionWithTags(args, optionsOrCb, cb) {
+        const command = new CreateStreamingDistributionWithTagsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.deleteCachePolicy = function (args, optionsOrCb, cb) {
-        var command = new DeleteCachePolicyCommand(args);
+    }
+    deleteCachePolicy(args, optionsOrCb, cb) {
+        const command = new DeleteCachePolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.deleteCloudFrontOriginAccessIdentity = function (args, optionsOrCb, cb) {
-        var command = new DeleteCloudFrontOriginAccessIdentityCommand(args);
+    }
+    deleteCloudFrontOriginAccessIdentity(args, optionsOrCb, cb) {
+        const command = new DeleteCloudFrontOriginAccessIdentityCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.deleteDistribution = function (args, optionsOrCb, cb) {
-        var command = new DeleteDistributionCommand(args);
+    }
+    deleteDistribution(args, optionsOrCb, cb) {
+        const command = new DeleteDistributionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.deleteFieldLevelEncryptionConfig = function (args, optionsOrCb, cb) {
-        var command = new DeleteFieldLevelEncryptionConfigCommand(args);
+    }
+    deleteFieldLevelEncryptionConfig(args, optionsOrCb, cb) {
+        const command = new DeleteFieldLevelEncryptionConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.deleteFieldLevelEncryptionProfile = function (args, optionsOrCb, cb) {
-        var command = new DeleteFieldLevelEncryptionProfileCommand(args);
+    }
+    deleteFieldLevelEncryptionProfile(args, optionsOrCb, cb) {
+        const command = new DeleteFieldLevelEncryptionProfileCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.deleteFunction = function (args, optionsOrCb, cb) {
-        var command = new DeleteFunctionCommand(args);
+    }
+    deleteFunction(args, optionsOrCb, cb) {
+        const command = new DeleteFunctionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.deleteKeyGroup = function (args, optionsOrCb, cb) {
-        var command = new DeleteKeyGroupCommand(args);
+    }
+    deleteKeyGroup(args, optionsOrCb, cb) {
+        const command = new DeleteKeyGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.deleteMonitoringSubscription = function (args, optionsOrCb, cb) {
-        var command = new DeleteMonitoringSubscriptionCommand(args);
+    }
+    deleteMonitoringSubscription(args, optionsOrCb, cb) {
+        const command = new DeleteMonitoringSubscriptionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.deleteOriginAccessControl = function (args, optionsOrCb, cb) {
-        var command = new DeleteOriginAccessControlCommand(args);
+    }
+    deleteOriginAccessControl(args, optionsOrCb, cb) {
+        const command = new DeleteOriginAccessControlCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.deleteOriginRequestPolicy = function (args, optionsOrCb, cb) {
-        var command = new DeleteOriginRequestPolicyCommand(args);
+    }
+    deleteOriginRequestPolicy(args, optionsOrCb, cb) {
+        const command = new DeleteOriginRequestPolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.deletePublicKey = function (args, optionsOrCb, cb) {
-        var command = new DeletePublicKeyCommand(args);
+    }
+    deletePublicKey(args, optionsOrCb, cb) {
+        const command = new DeletePublicKeyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.deleteRealtimeLogConfig = function (args, optionsOrCb, cb) {
-        var command = new DeleteRealtimeLogConfigCommand(args);
+    }
+    deleteRealtimeLogConfig(args, optionsOrCb, cb) {
+        const command = new DeleteRealtimeLogConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.deleteResponseHeadersPolicy = function (args, optionsOrCb, cb) {
-        var command = new DeleteResponseHeadersPolicyCommand(args);
+    }
+    deleteResponseHeadersPolicy(args, optionsOrCb, cb) {
+        const command = new DeleteResponseHeadersPolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.deleteStreamingDistribution = function (args, optionsOrCb, cb) {
-        var command = new DeleteStreamingDistributionCommand(args);
+    }
+    deleteStreamingDistribution(args, optionsOrCb, cb) {
+        const command = new DeleteStreamingDistributionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.describeFunction = function (args, optionsOrCb, cb) {
-        var command = new DescribeFunctionCommand(args);
+    }
+    describeFunction(args, optionsOrCb, cb) {
+        const command = new DescribeFunctionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.getCachePolicy = function (args, optionsOrCb, cb) {
-        var command = new GetCachePolicyCommand(args);
+    }
+    getCachePolicy(args, optionsOrCb, cb) {
+        const command = new GetCachePolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.getCachePolicyConfig = function (args, optionsOrCb, cb) {
-        var command = new GetCachePolicyConfigCommand(args);
+    }
+    getCachePolicyConfig(args, optionsOrCb, cb) {
+        const command = new GetCachePolicyConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.getCloudFrontOriginAccessIdentity = function (args, optionsOrCb, cb) {
-        var command = new GetCloudFrontOriginAccessIdentityCommand(args);
+    }
+    getCloudFrontOriginAccessIdentity(args, optionsOrCb, cb) {
+        const command = new GetCloudFrontOriginAccessIdentityCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.getCloudFrontOriginAccessIdentityConfig = function (args, optionsOrCb, cb) {
-        var command = new GetCloudFrontOriginAccessIdentityConfigCommand(args);
+    }
+    getCloudFrontOriginAccessIdentityConfig(args, optionsOrCb, cb) {
+        const command = new GetCloudFrontOriginAccessIdentityConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.getDistribution = function (args, optionsOrCb, cb) {
-        var command = new GetDistributionCommand(args);
+    }
+    getDistribution(args, optionsOrCb, cb) {
+        const command = new GetDistributionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.getDistributionConfig = function (args, optionsOrCb, cb) {
-        var command = new GetDistributionConfigCommand(args);
+    }
+    getDistributionConfig(args, optionsOrCb, cb) {
+        const command = new GetDistributionConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.getFieldLevelEncryption = function (args, optionsOrCb, cb) {
-        var command = new GetFieldLevelEncryptionCommand(args);
+    }
+    getFieldLevelEncryption(args, optionsOrCb, cb) {
+        const command = new GetFieldLevelEncryptionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.getFieldLevelEncryptionConfig = function (args, optionsOrCb, cb) {
-        var command = new GetFieldLevelEncryptionConfigCommand(args);
+    }
+    getFieldLevelEncryptionConfig(args, optionsOrCb, cb) {
+        const command = new GetFieldLevelEncryptionConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.getFieldLevelEncryptionProfile = function (args, optionsOrCb, cb) {
-        var command = new GetFieldLevelEncryptionProfileCommand(args);
+    }
+    getFieldLevelEncryptionProfile(args, optionsOrCb, cb) {
+        const command = new GetFieldLevelEncryptionProfileCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.getFieldLevelEncryptionProfileConfig = function (args, optionsOrCb, cb) {
-        var command = new GetFieldLevelEncryptionProfileConfigCommand(args);
+    }
+    getFieldLevelEncryptionProfileConfig(args, optionsOrCb, cb) {
+        const command = new GetFieldLevelEncryptionProfileConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.getFunction = function (args, optionsOrCb, cb) {
-        var command = new GetFunctionCommand(args);
+    }
+    getFunction(args, optionsOrCb, cb) {
+        const command = new GetFunctionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.getInvalidation = function (args, optionsOrCb, cb) {
-        var command = new GetInvalidationCommand(args);
+    }
+    getInvalidation(args, optionsOrCb, cb) {
+        const command = new GetInvalidationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.getKeyGroup = function (args, optionsOrCb, cb) {
-        var command = new GetKeyGroupCommand(args);
+    }
+    getKeyGroup(args, optionsOrCb, cb) {
+        const command = new GetKeyGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.getKeyGroupConfig = function (args, optionsOrCb, cb) {
-        var command = new GetKeyGroupConfigCommand(args);
+    }
+    getKeyGroupConfig(args, optionsOrCb, cb) {
+        const command = new GetKeyGroupConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.getMonitoringSubscription = function (args, optionsOrCb, cb) {
-        var command = new GetMonitoringSubscriptionCommand(args);
+    }
+    getMonitoringSubscription(args, optionsOrCb, cb) {
+        const command = new GetMonitoringSubscriptionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.getOriginAccessControl = function (args, optionsOrCb, cb) {
-        var command = new GetOriginAccessControlCommand(args);
+    }
+    getOriginAccessControl(args, optionsOrCb, cb) {
+        const command = new GetOriginAccessControlCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.getOriginAccessControlConfig = function (args, optionsOrCb, cb) {
-        var command = new GetOriginAccessControlConfigCommand(args);
+    }
+    getOriginAccessControlConfig(args, optionsOrCb, cb) {
+        const command = new GetOriginAccessControlConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.getOriginRequestPolicy = function (args, optionsOrCb, cb) {
-        var command = new GetOriginRequestPolicyCommand(args);
+    }
+    getOriginRequestPolicy(args, optionsOrCb, cb) {
+        const command = new GetOriginRequestPolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.getOriginRequestPolicyConfig = function (args, optionsOrCb, cb) {
-        var command = new GetOriginRequestPolicyConfigCommand(args);
+    }
+    getOriginRequestPolicyConfig(args, optionsOrCb, cb) {
+        const command = new GetOriginRequestPolicyConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.getPublicKey = function (args, optionsOrCb, cb) {
-        var command = new GetPublicKeyCommand(args);
+    }
+    getPublicKey(args, optionsOrCb, cb) {
+        const command = new GetPublicKeyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.getPublicKeyConfig = function (args, optionsOrCb, cb) {
-        var command = new GetPublicKeyConfigCommand(args);
+    }
+    getPublicKeyConfig(args, optionsOrCb, cb) {
+        const command = new GetPublicKeyConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.getRealtimeLogConfig = function (args, optionsOrCb, cb) {
-        var command = new GetRealtimeLogConfigCommand(args);
+    }
+    getRealtimeLogConfig(args, optionsOrCb, cb) {
+        const command = new GetRealtimeLogConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.getResponseHeadersPolicy = function (args, optionsOrCb, cb) {
-        var command = new GetResponseHeadersPolicyCommand(args);
+    }
+    getResponseHeadersPolicy(args, optionsOrCb, cb) {
+        const command = new GetResponseHeadersPolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.getResponseHeadersPolicyConfig = function (args, optionsOrCb, cb) {
-        var command = new GetResponseHeadersPolicyConfigCommand(args);
+    }
+    getResponseHeadersPolicyConfig(args, optionsOrCb, cb) {
+        const command = new GetResponseHeadersPolicyConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.getStreamingDistribution = function (args, optionsOrCb, cb) {
-        var command = new GetStreamingDistributionCommand(args);
+    }
+    getStreamingDistribution(args, optionsOrCb, cb) {
+        const command = new GetStreamingDistributionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.getStreamingDistributionConfig = function (args, optionsOrCb, cb) {
-        var command = new GetStreamingDistributionConfigCommand(args);
+    }
+    getStreamingDistributionConfig(args, optionsOrCb, cb) {
+        const command = new GetStreamingDistributionConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.listCachePolicies = function (args, optionsOrCb, cb) {
-        var command = new ListCachePoliciesCommand(args);
+    }
+    listCachePolicies(args, optionsOrCb, cb) {
+        const command = new ListCachePoliciesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.listCloudFrontOriginAccessIdentities = function (args, optionsOrCb, cb) {
-        var command = new ListCloudFrontOriginAccessIdentitiesCommand(args);
+    }
+    listCloudFrontOriginAccessIdentities(args, optionsOrCb, cb) {
+        const command = new ListCloudFrontOriginAccessIdentitiesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.listConflictingAliases = function (args, optionsOrCb, cb) {
-        var command = new ListConflictingAliasesCommand(args);
+    }
+    listConflictingAliases(args, optionsOrCb, cb) {
+        const command = new ListConflictingAliasesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.listDistributions = function (args, optionsOrCb, cb) {
-        var command = new ListDistributionsCommand(args);
+    }
+    listDistributions(args, optionsOrCb, cb) {
+        const command = new ListDistributionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.listDistributionsByCachePolicyId = function (args, optionsOrCb, cb) {
-        var command = new ListDistributionsByCachePolicyIdCommand(args);
+    }
+    listDistributionsByCachePolicyId(args, optionsOrCb, cb) {
+        const command = new ListDistributionsByCachePolicyIdCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.listDistributionsByKeyGroup = function (args, optionsOrCb, cb) {
-        var command = new ListDistributionsByKeyGroupCommand(args);
+    }
+    listDistributionsByKeyGroup(args, optionsOrCb, cb) {
+        const command = new ListDistributionsByKeyGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.listDistributionsByOriginRequestPolicyId = function (args, optionsOrCb, cb) {
-        var command = new ListDistributionsByOriginRequestPolicyIdCommand(args);
+    }
+    listDistributionsByOriginRequestPolicyId(args, optionsOrCb, cb) {
+        const command = new ListDistributionsByOriginRequestPolicyIdCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.listDistributionsByRealtimeLogConfig = function (args, optionsOrCb, cb) {
-        var command = new ListDistributionsByRealtimeLogConfigCommand(args);
+    }
+    listDistributionsByRealtimeLogConfig(args, optionsOrCb, cb) {
+        const command = new ListDistributionsByRealtimeLogConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.listDistributionsByResponseHeadersPolicyId = function (args, optionsOrCb, cb) {
-        var command = new ListDistributionsByResponseHeadersPolicyIdCommand(args);
+    }
+    listDistributionsByResponseHeadersPolicyId(args, optionsOrCb, cb) {
+        const command = new ListDistributionsByResponseHeadersPolicyIdCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.listDistributionsByWebACLId = function (args, optionsOrCb, cb) {
-        var command = new ListDistributionsByWebACLIdCommand(args);
+    }
+    listDistributionsByWebACLId(args, optionsOrCb, cb) {
+        const command = new ListDistributionsByWebACLIdCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.listFieldLevelEncryptionConfigs = function (args, optionsOrCb, cb) {
-        var command = new ListFieldLevelEncryptionConfigsCommand(args);
+    }
+    listFieldLevelEncryptionConfigs(args, optionsOrCb, cb) {
+        const command = new ListFieldLevelEncryptionConfigsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.listFieldLevelEncryptionProfiles = function (args, optionsOrCb, cb) {
-        var command = new ListFieldLevelEncryptionProfilesCommand(args);
+    }
+    listFieldLevelEncryptionProfiles(args, optionsOrCb, cb) {
+        const command = new ListFieldLevelEncryptionProfilesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.listFunctions = function (args, optionsOrCb, cb) {
-        var command = new ListFunctionsCommand(args);
+    }
+    listFunctions(args, optionsOrCb, cb) {
+        const command = new ListFunctionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.listInvalidations = function (args, optionsOrCb, cb) {
-        var command = new ListInvalidationsCommand(args);
+    }
+    listInvalidations(args, optionsOrCb, cb) {
+        const command = new ListInvalidationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.listKeyGroups = function (args, optionsOrCb, cb) {
-        var command = new ListKeyGroupsCommand(args);
+    }
+    listKeyGroups(args, optionsOrCb, cb) {
+        const command = new ListKeyGroupsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.listOriginAccessControls = function (args, optionsOrCb, cb) {
-        var command = new ListOriginAccessControlsCommand(args);
+    }
+    listOriginAccessControls(args, optionsOrCb, cb) {
+        const command = new ListOriginAccessControlsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.listOriginRequestPolicies = function (args, optionsOrCb, cb) {
-        var command = new ListOriginRequestPoliciesCommand(args);
+    }
+    listOriginRequestPolicies(args, optionsOrCb, cb) {
+        const command = new ListOriginRequestPoliciesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.listPublicKeys = function (args, optionsOrCb, cb) {
-        var command = new ListPublicKeysCommand(args);
+    }
+    listPublicKeys(args, optionsOrCb, cb) {
+        const command = new ListPublicKeysCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.listRealtimeLogConfigs = function (args, optionsOrCb, cb) {
-        var command = new ListRealtimeLogConfigsCommand(args);
+    }
+    listRealtimeLogConfigs(args, optionsOrCb, cb) {
+        const command = new ListRealtimeLogConfigsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.listResponseHeadersPolicies = function (args, optionsOrCb, cb) {
-        var command = new ListResponseHeadersPoliciesCommand(args);
+    }
+    listResponseHeadersPolicies(args, optionsOrCb, cb) {
+        const command = new ListResponseHeadersPoliciesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.listStreamingDistributions = function (args, optionsOrCb, cb) {
-        var command = new ListStreamingDistributionsCommand(args);
+    }
+    listStreamingDistributions(args, optionsOrCb, cb) {
+        const command = new ListStreamingDistributionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.listTagsForResource = function (args, optionsOrCb, cb) {
-        var command = new ListTagsForResourceCommand(args);
+    }
+    listTagsForResource(args, optionsOrCb, cb) {
+        const command = new ListTagsForResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.publishFunction = function (args, optionsOrCb, cb) {
-        var command = new PublishFunctionCommand(args);
+    }
+    publishFunction(args, optionsOrCb, cb) {
+        const command = new PublishFunctionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.tagResource = function (args, optionsOrCb, cb) {
-        var command = new TagResourceCommand(args);
+    }
+    tagResource(args, optionsOrCb, cb) {
+        const command = new TagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.testFunction = function (args, optionsOrCb, cb) {
-        var command = new TestFunctionCommand(args);
+    }
+    testFunction(args, optionsOrCb, cb) {
+        const command = new TestFunctionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.untagResource = function (args, optionsOrCb, cb) {
-        var command = new UntagResourceCommand(args);
+    }
+    untagResource(args, optionsOrCb, cb) {
+        const command = new UntagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.updateCachePolicy = function (args, optionsOrCb, cb) {
-        var command = new UpdateCachePolicyCommand(args);
+    }
+    updateCachePolicy(args, optionsOrCb, cb) {
+        const command = new UpdateCachePolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.updateCloudFrontOriginAccessIdentity = function (args, optionsOrCb, cb) {
-        var command = new UpdateCloudFrontOriginAccessIdentityCommand(args);
+    }
+    updateCloudFrontOriginAccessIdentity(args, optionsOrCb, cb) {
+        const command = new UpdateCloudFrontOriginAccessIdentityCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.updateDistribution = function (args, optionsOrCb, cb) {
-        var command = new UpdateDistributionCommand(args);
+    }
+    updateDistribution(args, optionsOrCb, cb) {
+        const command = new UpdateDistributionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.updateFieldLevelEncryptionConfig = function (args, optionsOrCb, cb) {
-        var command = new UpdateFieldLevelEncryptionConfigCommand(args);
+    }
+    updateFieldLevelEncryptionConfig(args, optionsOrCb, cb) {
+        const command = new UpdateFieldLevelEncryptionConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.updateFieldLevelEncryptionProfile = function (args, optionsOrCb, cb) {
-        var command = new UpdateFieldLevelEncryptionProfileCommand(args);
+    }
+    updateFieldLevelEncryptionProfile(args, optionsOrCb, cb) {
+        const command = new UpdateFieldLevelEncryptionProfileCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.updateFunction = function (args, optionsOrCb, cb) {
-        var command = new UpdateFunctionCommand(args);
+    }
+    updateFunction(args, optionsOrCb, cb) {
+        const command = new UpdateFunctionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.updateKeyGroup = function (args, optionsOrCb, cb) {
-        var command = new UpdateKeyGroupCommand(args);
+    }
+    updateKeyGroup(args, optionsOrCb, cb) {
+        const command = new UpdateKeyGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.updateOriginAccessControl = function (args, optionsOrCb, cb) {
-        var command = new UpdateOriginAccessControlCommand(args);
+    }
+    updateOriginAccessControl(args, optionsOrCb, cb) {
+        const command = new UpdateOriginAccessControlCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.updateOriginRequestPolicy = function (args, optionsOrCb, cb) {
-        var command = new UpdateOriginRequestPolicyCommand(args);
+    }
+    updateOriginRequestPolicy(args, optionsOrCb, cb) {
+        const command = new UpdateOriginRequestPolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.updatePublicKey = function (args, optionsOrCb, cb) {
-        var command = new UpdatePublicKeyCommand(args);
+    }
+    updatePublicKey(args, optionsOrCb, cb) {
+        const command = new UpdatePublicKeyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.updateRealtimeLogConfig = function (args, optionsOrCb, cb) {
-        var command = new UpdateRealtimeLogConfigCommand(args);
+    }
+    updateRealtimeLogConfig(args, optionsOrCb, cb) {
+        const command = new UpdateRealtimeLogConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.updateResponseHeadersPolicy = function (args, optionsOrCb, cb) {
-        var command = new UpdateResponseHeadersPolicyCommand(args);
+    }
+    updateResponseHeadersPolicy(args, optionsOrCb, cb) {
+        const command = new UpdateResponseHeadersPolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    CloudFront.prototype.updateStreamingDistribution = function (args, optionsOrCb, cb) {
-        var command = new UpdateStreamingDistributionCommand(args);
+    }
+    updateStreamingDistribution(args, optionsOrCb, cb) {
+        const command = new UpdateStreamingDistributionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    return CloudFront;
-}(CloudFrontClient));
-export { CloudFront };
+    }
+}