@aws-sdk/client-cloudfront 3.183.0 → 3.185.0

package/dist-es/CloudFront.js

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