@aws-sdk/client-route-53 3.183.0 → 3.185.0

package/dist-es/Route53.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { ActivateKeySigningKeyCommand, } from "./commands/ActivateKeySigningKeyCommand";
 import { AssociateVPCWithHostedZoneCommand, } from "./commands/AssociateVPCWithHostedZoneCommand";
 import { ChangeCidrCollectionCommand, } from "./commands/ChangeCidrCollectionCommand";
@@ -69,985 +70,991 @@ import { UpdateHostedZoneCommentCommand, } from "./commands/UpdateHostedZoneComm
 import { UpdateTrafficPolicyCommentCommand, } from "./commands/UpdateTrafficPolicyCommentCommand";
 import { UpdateTrafficPolicyInstanceCommand, } from "./commands/UpdateTrafficPolicyInstanceCommand";
 import { Route53Client } from "./Route53Client";
-export class Route53 extends Route53Client {
-    activateKeySigningKey(args, optionsOrCb, cb) {
-        const command = new ActivateKeySigningKeyCommand(args);
+var Route53 = (function (_super) {
+    __extends(Route53, _super);
+    function Route53() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Route53.prototype.activateKeySigningKey = function (args, optionsOrCb, cb) {
+        var command = new ActivateKeySigningKeyCommand(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);
         }
-    }
-    associateVPCWithHostedZone(args, optionsOrCb, cb) {
-        const command = new AssociateVPCWithHostedZoneCommand(args);
+    };
+    Route53.prototype.associateVPCWithHostedZone = function (args, optionsOrCb, cb) {
+        var command = new AssociateVPCWithHostedZoneCommand(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);
         }
-    }
-    changeCidrCollection(args, optionsOrCb, cb) {
-        const command = new ChangeCidrCollectionCommand(args);
+    };
+    Route53.prototype.changeCidrCollection = function (args, optionsOrCb, cb) {
+        var command = new ChangeCidrCollectionCommand(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);
         }
-    }
-    changeResourceRecordSets(args, optionsOrCb, cb) {
-        const command = new ChangeResourceRecordSetsCommand(args);
+    };
+    Route53.prototype.changeResourceRecordSets = function (args, optionsOrCb, cb) {
+        var command = new ChangeResourceRecordSetsCommand(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);
         }
-    }
-    changeTagsForResource(args, optionsOrCb, cb) {
-        const command = new ChangeTagsForResourceCommand(args);
+    };
+    Route53.prototype.changeTagsForResource = function (args, optionsOrCb, cb) {
+        var command = new ChangeTagsForResourceCommand(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);
         }
-    }
-    createCidrCollection(args, optionsOrCb, cb) {
-        const command = new CreateCidrCollectionCommand(args);
+    };
+    Route53.prototype.createCidrCollection = function (args, optionsOrCb, cb) {
+        var command = new CreateCidrCollectionCommand(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);
         }
-    }
-    createHealthCheck(args, optionsOrCb, cb) {
-        const command = new CreateHealthCheckCommand(args);
+    };
+    Route53.prototype.createHealthCheck = function (args, optionsOrCb, cb) {
+        var command = new CreateHealthCheckCommand(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);
         }
-    }
-    createHostedZone(args, optionsOrCb, cb) {
-        const command = new CreateHostedZoneCommand(args);
+    };
+    Route53.prototype.createHostedZone = function (args, optionsOrCb, cb) {
+        var command = new CreateHostedZoneCommand(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);
         }
-    }
-    createKeySigningKey(args, optionsOrCb, cb) {
-        const command = new CreateKeySigningKeyCommand(args);
+    };
+    Route53.prototype.createKeySigningKey = function (args, optionsOrCb, cb) {
+        var command = new CreateKeySigningKeyCommand(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);
         }
-    }
-    createQueryLoggingConfig(args, optionsOrCb, cb) {
-        const command = new CreateQueryLoggingConfigCommand(args);
+    };
+    Route53.prototype.createQueryLoggingConfig = function (args, optionsOrCb, cb) {
+        var command = new CreateQueryLoggingConfigCommand(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);
         }
-    }
-    createReusableDelegationSet(args, optionsOrCb, cb) {
-        const command = new CreateReusableDelegationSetCommand(args);
+    };
+    Route53.prototype.createReusableDelegationSet = function (args, optionsOrCb, cb) {
+        var command = new CreateReusableDelegationSetCommand(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);
         }
-    }
-    createTrafficPolicy(args, optionsOrCb, cb) {
-        const command = new CreateTrafficPolicyCommand(args);
+    };
+    Route53.prototype.createTrafficPolicy = function (args, optionsOrCb, cb) {
+        var command = new CreateTrafficPolicyCommand(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);
         }
-    }
-    createTrafficPolicyInstance(args, optionsOrCb, cb) {
-        const command = new CreateTrafficPolicyInstanceCommand(args);
+    };
+    Route53.prototype.createTrafficPolicyInstance = function (args, optionsOrCb, cb) {
+        var command = new CreateTrafficPolicyInstanceCommand(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);
         }
-    }
-    createTrafficPolicyVersion(args, optionsOrCb, cb) {
-        const command = new CreateTrafficPolicyVersionCommand(args);
+    };
+    Route53.prototype.createTrafficPolicyVersion = function (args, optionsOrCb, cb) {
+        var command = new CreateTrafficPolicyVersionCommand(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);
         }
-    }
-    createVPCAssociationAuthorization(args, optionsOrCb, cb) {
-        const command = new CreateVPCAssociationAuthorizationCommand(args);
+    };
+    Route53.prototype.createVPCAssociationAuthorization = function (args, optionsOrCb, cb) {
+        var command = new CreateVPCAssociationAuthorizationCommand(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);
         }
-    }
-    deactivateKeySigningKey(args, optionsOrCb, cb) {
-        const command = new DeactivateKeySigningKeyCommand(args);
+    };
+    Route53.prototype.deactivateKeySigningKey = function (args, optionsOrCb, cb) {
+        var command = new DeactivateKeySigningKeyCommand(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);
         }
-    }
-    deleteCidrCollection(args, optionsOrCb, cb) {
-        const command = new DeleteCidrCollectionCommand(args);
+    };
+    Route53.prototype.deleteCidrCollection = function (args, optionsOrCb, cb) {
+        var command = new DeleteCidrCollectionCommand(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);
         }
-    }
-    deleteHealthCheck(args, optionsOrCb, cb) {
-        const command = new DeleteHealthCheckCommand(args);
+    };
+    Route53.prototype.deleteHealthCheck = function (args, optionsOrCb, cb) {
+        var command = new DeleteHealthCheckCommand(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);
         }
-    }
-    deleteHostedZone(args, optionsOrCb, cb) {
-        const command = new DeleteHostedZoneCommand(args);
+    };
+    Route53.prototype.deleteHostedZone = function (args, optionsOrCb, cb) {
+        var command = new DeleteHostedZoneCommand(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);
         }
-    }
-    deleteKeySigningKey(args, optionsOrCb, cb) {
-        const command = new DeleteKeySigningKeyCommand(args);
+    };
+    Route53.prototype.deleteKeySigningKey = function (args, optionsOrCb, cb) {
+        var command = new DeleteKeySigningKeyCommand(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);
         }
-    }
-    deleteQueryLoggingConfig(args, optionsOrCb, cb) {
-        const command = new DeleteQueryLoggingConfigCommand(args);
+    };
+    Route53.prototype.deleteQueryLoggingConfig = function (args, optionsOrCb, cb) {
+        var command = new DeleteQueryLoggingConfigCommand(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);
         }
-    }
-    deleteReusableDelegationSet(args, optionsOrCb, cb) {
-        const command = new DeleteReusableDelegationSetCommand(args);
+    };
+    Route53.prototype.deleteReusableDelegationSet = function (args, optionsOrCb, cb) {
+        var command = new DeleteReusableDelegationSetCommand(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);
         }
-    }
-    deleteTrafficPolicy(args, optionsOrCb, cb) {
-        const command = new DeleteTrafficPolicyCommand(args);
+    };
+    Route53.prototype.deleteTrafficPolicy = function (args, optionsOrCb, cb) {
+        var command = new DeleteTrafficPolicyCommand(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);
         }
-    }
-    deleteTrafficPolicyInstance(args, optionsOrCb, cb) {
-        const command = new DeleteTrafficPolicyInstanceCommand(args);
+    };
+    Route53.prototype.deleteTrafficPolicyInstance = function (args, optionsOrCb, cb) {
+        var command = new DeleteTrafficPolicyInstanceCommand(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);
         }
-    }
-    deleteVPCAssociationAuthorization(args, optionsOrCb, cb) {
-        const command = new DeleteVPCAssociationAuthorizationCommand(args);
+    };
+    Route53.prototype.deleteVPCAssociationAuthorization = function (args, optionsOrCb, cb) {
+        var command = new DeleteVPCAssociationAuthorizationCommand(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);
         }
-    }
-    disableHostedZoneDNSSEC(args, optionsOrCb, cb) {
-        const command = new DisableHostedZoneDNSSECCommand(args);
+    };
+    Route53.prototype.disableHostedZoneDNSSEC = function (args, optionsOrCb, cb) {
+        var command = new DisableHostedZoneDNSSECCommand(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);
         }
-    }
-    disassociateVPCFromHostedZone(args, optionsOrCb, cb) {
-        const command = new DisassociateVPCFromHostedZoneCommand(args);
+    };
+    Route53.prototype.disassociateVPCFromHostedZone = function (args, optionsOrCb, cb) {
+        var command = new DisassociateVPCFromHostedZoneCommand(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);
         }
-    }
-    enableHostedZoneDNSSEC(args, optionsOrCb, cb) {
-        const command = new EnableHostedZoneDNSSECCommand(args);
+    };
+    Route53.prototype.enableHostedZoneDNSSEC = function (args, optionsOrCb, cb) {
+        var command = new EnableHostedZoneDNSSECCommand(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);
         }
-    }
-    getAccountLimit(args, optionsOrCb, cb) {
-        const command = new GetAccountLimitCommand(args);
+    };
+    Route53.prototype.getAccountLimit = function (args, optionsOrCb, cb) {
+        var command = new GetAccountLimitCommand(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);
         }
-    }
-    getChange(args, optionsOrCb, cb) {
-        const command = new GetChangeCommand(args);
+    };
+    Route53.prototype.getChange = function (args, optionsOrCb, cb) {
+        var command = new GetChangeCommand(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);
         }
-    }
-    getCheckerIpRanges(args, optionsOrCb, cb) {
-        const command = new GetCheckerIpRangesCommand(args);
+    };
+    Route53.prototype.getCheckerIpRanges = function (args, optionsOrCb, cb) {
+        var command = new GetCheckerIpRangesCommand(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);
         }
-    }
-    getDNSSEC(args, optionsOrCb, cb) {
-        const command = new GetDNSSECCommand(args);
+    };
+    Route53.prototype.getDNSSEC = function (args, optionsOrCb, cb) {
+        var command = new GetDNSSECCommand(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);
         }
-    }
-    getGeoLocation(args, optionsOrCb, cb) {
-        const command = new GetGeoLocationCommand(args);
+    };
+    Route53.prototype.getGeoLocation = function (args, optionsOrCb, cb) {
+        var command = new GetGeoLocationCommand(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);
         }
-    }
-    getHealthCheck(args, optionsOrCb, cb) {
-        const command = new GetHealthCheckCommand(args);
+    };
+    Route53.prototype.getHealthCheck = function (args, optionsOrCb, cb) {
+        var command = new GetHealthCheckCommand(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);
         }
-    }
-    getHealthCheckCount(args, optionsOrCb, cb) {
-        const command = new GetHealthCheckCountCommand(args);
+    };
+    Route53.prototype.getHealthCheckCount = function (args, optionsOrCb, cb) {
+        var command = new GetHealthCheckCountCommand(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);
         }
-    }
-    getHealthCheckLastFailureReason(args, optionsOrCb, cb) {
-        const command = new GetHealthCheckLastFailureReasonCommand(args);
+    };
+    Route53.prototype.getHealthCheckLastFailureReason = function (args, optionsOrCb, cb) {
+        var command = new GetHealthCheckLastFailureReasonCommand(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);
         }
-    }
-    getHealthCheckStatus(args, optionsOrCb, cb) {
-        const command = new GetHealthCheckStatusCommand(args);
+    };
+    Route53.prototype.getHealthCheckStatus = function (args, optionsOrCb, cb) {
+        var command = new GetHealthCheckStatusCommand(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);
         }
-    }
-    getHostedZone(args, optionsOrCb, cb) {
-        const command = new GetHostedZoneCommand(args);
+    };
+    Route53.prototype.getHostedZone = function (args, optionsOrCb, cb) {
+        var command = new GetHostedZoneCommand(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);
         }
-    }
-    getHostedZoneCount(args, optionsOrCb, cb) {
-        const command = new GetHostedZoneCountCommand(args);
+    };
+    Route53.prototype.getHostedZoneCount = function (args, optionsOrCb, cb) {
+        var command = new GetHostedZoneCountCommand(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);
         }
-    }
-    getHostedZoneLimit(args, optionsOrCb, cb) {
-        const command = new GetHostedZoneLimitCommand(args);
+    };
+    Route53.prototype.getHostedZoneLimit = function (args, optionsOrCb, cb) {
+        var command = new GetHostedZoneLimitCommand(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);
         }
-    }
-    getQueryLoggingConfig(args, optionsOrCb, cb) {
-        const command = new GetQueryLoggingConfigCommand(args);
+    };
+    Route53.prototype.getQueryLoggingConfig = function (args, optionsOrCb, cb) {
+        var command = new GetQueryLoggingConfigCommand(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);
         }
-    }
-    getReusableDelegationSet(args, optionsOrCb, cb) {
-        const command = new GetReusableDelegationSetCommand(args);
+    };
+    Route53.prototype.getReusableDelegationSet = function (args, optionsOrCb, cb) {
+        var command = new GetReusableDelegationSetCommand(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);
         }
-    }
-    getReusableDelegationSetLimit(args, optionsOrCb, cb) {
-        const command = new GetReusableDelegationSetLimitCommand(args);
+    };
+    Route53.prototype.getReusableDelegationSetLimit = function (args, optionsOrCb, cb) {
+        var command = new GetReusableDelegationSetLimitCommand(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);
         }
-    }
-    getTrafficPolicy(args, optionsOrCb, cb) {
-        const command = new GetTrafficPolicyCommand(args);
+    };
+    Route53.prototype.getTrafficPolicy = function (args, optionsOrCb, cb) {
+        var command = new GetTrafficPolicyCommand(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);
         }
-    }
-    getTrafficPolicyInstance(args, optionsOrCb, cb) {
-        const command = new GetTrafficPolicyInstanceCommand(args);
+    };
+    Route53.prototype.getTrafficPolicyInstance = function (args, optionsOrCb, cb) {
+        var command = new GetTrafficPolicyInstanceCommand(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);
         }
-    }
-    getTrafficPolicyInstanceCount(args, optionsOrCb, cb) {
-        const command = new GetTrafficPolicyInstanceCountCommand(args);
+    };
+    Route53.prototype.getTrafficPolicyInstanceCount = function (args, optionsOrCb, cb) {
+        var command = new GetTrafficPolicyInstanceCountCommand(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);
         }
-    }
-    listCidrBlocks(args, optionsOrCb, cb) {
-        const command = new ListCidrBlocksCommand(args);
+    };
+    Route53.prototype.listCidrBlocks = function (args, optionsOrCb, cb) {
+        var command = new ListCidrBlocksCommand(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);
         }
-    }
-    listCidrCollections(args, optionsOrCb, cb) {
-        const command = new ListCidrCollectionsCommand(args);
+    };
+    Route53.prototype.listCidrCollections = function (args, optionsOrCb, cb) {
+        var command = new ListCidrCollectionsCommand(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);
         }
-    }
-    listCidrLocations(args, optionsOrCb, cb) {
-        const command = new ListCidrLocationsCommand(args);
+    };
+    Route53.prototype.listCidrLocations = function (args, optionsOrCb, cb) {
+        var command = new ListCidrLocationsCommand(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);
         }
-    }
-    listGeoLocations(args, optionsOrCb, cb) {
-        const command = new ListGeoLocationsCommand(args);
+    };
+    Route53.prototype.listGeoLocations = function (args, optionsOrCb, cb) {
+        var command = new ListGeoLocationsCommand(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);
         }
-    }
-    listHealthChecks(args, optionsOrCb, cb) {
-        const command = new ListHealthChecksCommand(args);
+    };
+    Route53.prototype.listHealthChecks = function (args, optionsOrCb, cb) {
+        var command = new ListHealthChecksCommand(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);
         }
-    }
-    listHostedZones(args, optionsOrCb, cb) {
-        const command = new ListHostedZonesCommand(args);
+    };
+    Route53.prototype.listHostedZones = function (args, optionsOrCb, cb) {
+        var command = new ListHostedZonesCommand(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);
         }
-    }
-    listHostedZonesByName(args, optionsOrCb, cb) {
-        const command = new ListHostedZonesByNameCommand(args);
+    };
+    Route53.prototype.listHostedZonesByName = function (args, optionsOrCb, cb) {
+        var command = new ListHostedZonesByNameCommand(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);
         }
-    }
-    listHostedZonesByVPC(args, optionsOrCb, cb) {
-        const command = new ListHostedZonesByVPCCommand(args);
+    };
+    Route53.prototype.listHostedZonesByVPC = function (args, optionsOrCb, cb) {
+        var command = new ListHostedZonesByVPCCommand(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);
         }
-    }
-    listQueryLoggingConfigs(args, optionsOrCb, cb) {
-        const command = new ListQueryLoggingConfigsCommand(args);
+    };
+    Route53.prototype.listQueryLoggingConfigs = function (args, optionsOrCb, cb) {
+        var command = new ListQueryLoggingConfigsCommand(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);
         }
-    }
-    listResourceRecordSets(args, optionsOrCb, cb) {
-        const command = new ListResourceRecordSetsCommand(args);
+    };
+    Route53.prototype.listResourceRecordSets = function (args, optionsOrCb, cb) {
+        var command = new ListResourceRecordSetsCommand(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);
         }
-    }
-    listReusableDelegationSets(args, optionsOrCb, cb) {
-        const command = new ListReusableDelegationSetsCommand(args);
+    };
+    Route53.prototype.listReusableDelegationSets = function (args, optionsOrCb, cb) {
+        var command = new ListReusableDelegationSetsCommand(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);
+    };
+    Route53.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);
         }
-    }
-    listTagsForResources(args, optionsOrCb, cb) {
-        const command = new ListTagsForResourcesCommand(args);
+    };
+    Route53.prototype.listTagsForResources = function (args, optionsOrCb, cb) {
+        var command = new ListTagsForResourcesCommand(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);
         }
-    }
-    listTrafficPolicies(args, optionsOrCb, cb) {
-        const command = new ListTrafficPoliciesCommand(args);
+    };
+    Route53.prototype.listTrafficPolicies = function (args, optionsOrCb, cb) {
+        var command = new ListTrafficPoliciesCommand(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);
         }
-    }
-    listTrafficPolicyInstances(args, optionsOrCb, cb) {
-        const command = new ListTrafficPolicyInstancesCommand(args);
+    };
+    Route53.prototype.listTrafficPolicyInstances = function (args, optionsOrCb, cb) {
+        var command = new ListTrafficPolicyInstancesCommand(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);
         }
-    }
-    listTrafficPolicyInstancesByHostedZone(args, optionsOrCb, cb) {
-        const command = new ListTrafficPolicyInstancesByHostedZoneCommand(args);
+    };
+    Route53.prototype.listTrafficPolicyInstancesByHostedZone = function (args, optionsOrCb, cb) {
+        var command = new ListTrafficPolicyInstancesByHostedZoneCommand(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);
         }
-    }
-    listTrafficPolicyInstancesByPolicy(args, optionsOrCb, cb) {
-        const command = new ListTrafficPolicyInstancesByPolicyCommand(args);
+    };
+    Route53.prototype.listTrafficPolicyInstancesByPolicy = function (args, optionsOrCb, cb) {
+        var command = new ListTrafficPolicyInstancesByPolicyCommand(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);
         }
-    }
-    listTrafficPolicyVersions(args, optionsOrCb, cb) {
-        const command = new ListTrafficPolicyVersionsCommand(args);
+    };
+    Route53.prototype.listTrafficPolicyVersions = function (args, optionsOrCb, cb) {
+        var command = new ListTrafficPolicyVersionsCommand(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);
         }
-    }
-    listVPCAssociationAuthorizations(args, optionsOrCb, cb) {
-        const command = new ListVPCAssociationAuthorizationsCommand(args);
+    };
+    Route53.prototype.listVPCAssociationAuthorizations = function (args, optionsOrCb, cb) {
+        var command = new ListVPCAssociationAuthorizationsCommand(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);
         }
-    }
-    testDNSAnswer(args, optionsOrCb, cb) {
-        const command = new TestDNSAnswerCommand(args);
+    };
+    Route53.prototype.testDNSAnswer = function (args, optionsOrCb, cb) {
+        var command = new TestDNSAnswerCommand(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);
         }
-    }
-    updateHealthCheck(args, optionsOrCb, cb) {
-        const command = new UpdateHealthCheckCommand(args);
+    };
+    Route53.prototype.updateHealthCheck = function (args, optionsOrCb, cb) {
+        var command = new UpdateHealthCheckCommand(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);
         }
-    }
-    updateHostedZoneComment(args, optionsOrCb, cb) {
-        const command = new UpdateHostedZoneCommentCommand(args);
+    };
+    Route53.prototype.updateHostedZoneComment = function (args, optionsOrCb, cb) {
+        var command = new UpdateHostedZoneCommentCommand(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);
         }
-    }
-    updateTrafficPolicyComment(args, optionsOrCb, cb) {
-        const command = new UpdateTrafficPolicyCommentCommand(args);
+    };
+    Route53.prototype.updateTrafficPolicyComment = function (args, optionsOrCb, cb) {
+        var command = new UpdateTrafficPolicyCommentCommand(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);
         }
-    }
-    updateTrafficPolicyInstance(args, optionsOrCb, cb) {
-        const command = new UpdateTrafficPolicyInstanceCommand(args);
+    };
+    Route53.prototype.updateTrafficPolicyInstance = function (args, optionsOrCb, cb) {
+        var command = new UpdateTrafficPolicyInstanceCommand(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 Route53;
+}(Route53Client));
+export { Route53 };