@aws-sdk/client-chime 3.181.0 → 3.183.0

package/dist-es/Chime.js

@@ -1,4 +1,3 @@
-import { __extends } from "tslib";
 import { ChimeClient } from "./ChimeClient";
 import { AssociatePhoneNumbersWithVoiceConnectorCommand, } from "./commands/AssociatePhoneNumbersWithVoiceConnectorCommand";
 import { AssociatePhoneNumbersWithVoiceConnectorGroupCommand, } from "./commands/AssociatePhoneNumbersWithVoiceConnectorGroupCommand";
@@ -191,2685 +190,2679 @@ import { UpdateUserSettingsCommand, } from "./commands/UpdateUserSettingsCommand
 import { UpdateVoiceConnectorCommand, } from "./commands/UpdateVoiceConnectorCommand";
 import { UpdateVoiceConnectorGroupCommand, } from "./commands/UpdateVoiceConnectorGroupCommand";
 import { ValidateE911AddressCommand, } from "./commands/ValidateE911AddressCommand";
-var Chime = (function (_super) {
-    __extends(Chime, _super);
-    function Chime() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    Chime.prototype.associatePhoneNumbersWithVoiceConnector = function (args, optionsOrCb, cb) {
-        var command = new AssociatePhoneNumbersWithVoiceConnectorCommand(args);
+export class Chime extends ChimeClient {
+    associatePhoneNumbersWithVoiceConnector(args, optionsOrCb, cb) {
+        const command = new AssociatePhoneNumbersWithVoiceConnectorCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.associatePhoneNumbersWithVoiceConnectorGroup = function (args, optionsOrCb, cb) {
-        var command = new AssociatePhoneNumbersWithVoiceConnectorGroupCommand(args);
+    }
+    associatePhoneNumbersWithVoiceConnectorGroup(args, optionsOrCb, cb) {
+        const command = new AssociatePhoneNumbersWithVoiceConnectorGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.associatePhoneNumberWithUser = function (args, optionsOrCb, cb) {
-        var command = new AssociatePhoneNumberWithUserCommand(args);
+    }
+    associatePhoneNumberWithUser(args, optionsOrCb, cb) {
+        const command = new AssociatePhoneNumberWithUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.associateSigninDelegateGroupsWithAccount = function (args, optionsOrCb, cb) {
-        var command = new AssociateSigninDelegateGroupsWithAccountCommand(args);
+    }
+    associateSigninDelegateGroupsWithAccount(args, optionsOrCb, cb) {
+        const command = new AssociateSigninDelegateGroupsWithAccountCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.batchCreateAttendee = function (args, optionsOrCb, cb) {
-        var command = new BatchCreateAttendeeCommand(args);
+    }
+    batchCreateAttendee(args, optionsOrCb, cb) {
+        const command = new BatchCreateAttendeeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.batchCreateChannelMembership = function (args, optionsOrCb, cb) {
-        var command = new BatchCreateChannelMembershipCommand(args);
+    }
+    batchCreateChannelMembership(args, optionsOrCb, cb) {
+        const command = new BatchCreateChannelMembershipCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.batchCreateRoomMembership = function (args, optionsOrCb, cb) {
-        var command = new BatchCreateRoomMembershipCommand(args);
+    }
+    batchCreateRoomMembership(args, optionsOrCb, cb) {
+        const command = new BatchCreateRoomMembershipCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.batchDeletePhoneNumber = function (args, optionsOrCb, cb) {
-        var command = new BatchDeletePhoneNumberCommand(args);
+    }
+    batchDeletePhoneNumber(args, optionsOrCb, cb) {
+        const command = new BatchDeletePhoneNumberCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.batchSuspendUser = function (args, optionsOrCb, cb) {
-        var command = new BatchSuspendUserCommand(args);
+    }
+    batchSuspendUser(args, optionsOrCb, cb) {
+        const command = new BatchSuspendUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.batchUnsuspendUser = function (args, optionsOrCb, cb) {
-        var command = new BatchUnsuspendUserCommand(args);
+    }
+    batchUnsuspendUser(args, optionsOrCb, cb) {
+        const command = new BatchUnsuspendUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.batchUpdatePhoneNumber = function (args, optionsOrCb, cb) {
-        var command = new BatchUpdatePhoneNumberCommand(args);
+    }
+    batchUpdatePhoneNumber(args, optionsOrCb, cb) {
+        const command = new BatchUpdatePhoneNumberCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.batchUpdateUser = function (args, optionsOrCb, cb) {
-        var command = new BatchUpdateUserCommand(args);
+    }
+    batchUpdateUser(args, optionsOrCb, cb) {
+        const command = new BatchUpdateUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.createAccount = function (args, optionsOrCb, cb) {
-        var command = new CreateAccountCommand(args);
+    }
+    createAccount(args, optionsOrCb, cb) {
+        const command = new CreateAccountCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.createAppInstance = function (args, optionsOrCb, cb) {
-        var command = new CreateAppInstanceCommand(args);
+    }
+    createAppInstance(args, optionsOrCb, cb) {
+        const command = new CreateAppInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.createAppInstanceAdmin = function (args, optionsOrCb, cb) {
-        var command = new CreateAppInstanceAdminCommand(args);
+    }
+    createAppInstanceAdmin(args, optionsOrCb, cb) {
+        const command = new CreateAppInstanceAdminCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.createAppInstanceUser = function (args, optionsOrCb, cb) {
-        var command = new CreateAppInstanceUserCommand(args);
+    }
+    createAppInstanceUser(args, optionsOrCb, cb) {
+        const command = new CreateAppInstanceUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.createAttendee = function (args, optionsOrCb, cb) {
-        var command = new CreateAttendeeCommand(args);
+    }
+    createAttendee(args, optionsOrCb, cb) {
+        const command = new CreateAttendeeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.createBot = function (args, optionsOrCb, cb) {
-        var command = new CreateBotCommand(args);
+    }
+    createBot(args, optionsOrCb, cb) {
+        const command = new CreateBotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.createChannel = function (args, optionsOrCb, cb) {
-        var command = new CreateChannelCommand(args);
+    }
+    createChannel(args, optionsOrCb, cb) {
+        const command = new CreateChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.createChannelBan = function (args, optionsOrCb, cb) {
-        var command = new CreateChannelBanCommand(args);
+    }
+    createChannelBan(args, optionsOrCb, cb) {
+        const command = new CreateChannelBanCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.createChannelMembership = function (args, optionsOrCb, cb) {
-        var command = new CreateChannelMembershipCommand(args);
+    }
+    createChannelMembership(args, optionsOrCb, cb) {
+        const command = new CreateChannelMembershipCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.createChannelModerator = function (args, optionsOrCb, cb) {
-        var command = new CreateChannelModeratorCommand(args);
+    }
+    createChannelModerator(args, optionsOrCb, cb) {
+        const command = new CreateChannelModeratorCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.createMediaCapturePipeline = function (args, optionsOrCb, cb) {
-        var command = new CreateMediaCapturePipelineCommand(args);
+    }
+    createMediaCapturePipeline(args, optionsOrCb, cb) {
+        const command = new CreateMediaCapturePipelineCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.createMeeting = function (args, optionsOrCb, cb) {
-        var command = new CreateMeetingCommand(args);
+    }
+    createMeeting(args, optionsOrCb, cb) {
+        const command = new CreateMeetingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.createMeetingDialOut = function (args, optionsOrCb, cb) {
-        var command = new CreateMeetingDialOutCommand(args);
+    }
+    createMeetingDialOut(args, optionsOrCb, cb) {
+        const command = new CreateMeetingDialOutCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.createMeetingWithAttendees = function (args, optionsOrCb, cb) {
-        var command = new CreateMeetingWithAttendeesCommand(args);
+    }
+    createMeetingWithAttendees(args, optionsOrCb, cb) {
+        const command = new CreateMeetingWithAttendeesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.createPhoneNumberOrder = function (args, optionsOrCb, cb) {
-        var command = new CreatePhoneNumberOrderCommand(args);
+    }
+    createPhoneNumberOrder(args, optionsOrCb, cb) {
+        const command = new CreatePhoneNumberOrderCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.createProxySession = function (args, optionsOrCb, cb) {
-        var command = new CreateProxySessionCommand(args);
+    }
+    createProxySession(args, optionsOrCb, cb) {
+        const command = new CreateProxySessionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.createRoom = function (args, optionsOrCb, cb) {
-        var command = new CreateRoomCommand(args);
+    }
+    createRoom(args, optionsOrCb, cb) {
+        const command = new CreateRoomCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.createRoomMembership = function (args, optionsOrCb, cb) {
-        var command = new CreateRoomMembershipCommand(args);
+    }
+    createRoomMembership(args, optionsOrCb, cb) {
+        const command = new CreateRoomMembershipCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.createSipMediaApplication = function (args, optionsOrCb, cb) {
-        var command = new CreateSipMediaApplicationCommand(args);
+    }
+    createSipMediaApplication(args, optionsOrCb, cb) {
+        const command = new CreateSipMediaApplicationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.createSipMediaApplicationCall = function (args, optionsOrCb, cb) {
-        var command = new CreateSipMediaApplicationCallCommand(args);
+    }
+    createSipMediaApplicationCall(args, optionsOrCb, cb) {
+        const command = new CreateSipMediaApplicationCallCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.createSipRule = function (args, optionsOrCb, cb) {
-        var command = new CreateSipRuleCommand(args);
+    }
+    createSipRule(args, optionsOrCb, cb) {
+        const command = new CreateSipRuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.createUser = function (args, optionsOrCb, cb) {
-        var command = new CreateUserCommand(args);
+    }
+    createUser(args, optionsOrCb, cb) {
+        const command = new CreateUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.createVoiceConnector = function (args, optionsOrCb, cb) {
-        var command = new CreateVoiceConnectorCommand(args);
+    }
+    createVoiceConnector(args, optionsOrCb, cb) {
+        const command = new CreateVoiceConnectorCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.createVoiceConnectorGroup = function (args, optionsOrCb, cb) {
-        var command = new CreateVoiceConnectorGroupCommand(args);
+    }
+    createVoiceConnectorGroup(args, optionsOrCb, cb) {
+        const command = new CreateVoiceConnectorGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteAccount = function (args, optionsOrCb, cb) {
-        var command = new DeleteAccountCommand(args);
+    }
+    deleteAccount(args, optionsOrCb, cb) {
+        const command = new DeleteAccountCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteAppInstance = function (args, optionsOrCb, cb) {
-        var command = new DeleteAppInstanceCommand(args);
+    }
+    deleteAppInstance(args, optionsOrCb, cb) {
+        const command = new DeleteAppInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteAppInstanceAdmin = function (args, optionsOrCb, cb) {
-        var command = new DeleteAppInstanceAdminCommand(args);
+    }
+    deleteAppInstanceAdmin(args, optionsOrCb, cb) {
+        const command = new DeleteAppInstanceAdminCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteAppInstanceStreamingConfigurations = function (args, optionsOrCb, cb) {
-        var command = new DeleteAppInstanceStreamingConfigurationsCommand(args);
+    }
+    deleteAppInstanceStreamingConfigurations(args, optionsOrCb, cb) {
+        const command = new DeleteAppInstanceStreamingConfigurationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteAppInstanceUser = function (args, optionsOrCb, cb) {
-        var command = new DeleteAppInstanceUserCommand(args);
+    }
+    deleteAppInstanceUser(args, optionsOrCb, cb) {
+        const command = new DeleteAppInstanceUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteAttendee = function (args, optionsOrCb, cb) {
-        var command = new DeleteAttendeeCommand(args);
+    }
+    deleteAttendee(args, optionsOrCb, cb) {
+        const command = new DeleteAttendeeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteChannel = function (args, optionsOrCb, cb) {
-        var command = new DeleteChannelCommand(args);
+    }
+    deleteChannel(args, optionsOrCb, cb) {
+        const command = new DeleteChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteChannelBan = function (args, optionsOrCb, cb) {
-        var command = new DeleteChannelBanCommand(args);
+    }
+    deleteChannelBan(args, optionsOrCb, cb) {
+        const command = new DeleteChannelBanCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteChannelMembership = function (args, optionsOrCb, cb) {
-        var command = new DeleteChannelMembershipCommand(args);
+    }
+    deleteChannelMembership(args, optionsOrCb, cb) {
+        const command = new DeleteChannelMembershipCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteChannelMessage = function (args, optionsOrCb, cb) {
-        var command = new DeleteChannelMessageCommand(args);
+    }
+    deleteChannelMessage(args, optionsOrCb, cb) {
+        const command = new DeleteChannelMessageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteChannelModerator = function (args, optionsOrCb, cb) {
-        var command = new DeleteChannelModeratorCommand(args);
+    }
+    deleteChannelModerator(args, optionsOrCb, cb) {
+        const command = new DeleteChannelModeratorCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteEventsConfiguration = function (args, optionsOrCb, cb) {
-        var command = new DeleteEventsConfigurationCommand(args);
+    }
+    deleteEventsConfiguration(args, optionsOrCb, cb) {
+        const command = new DeleteEventsConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteMediaCapturePipeline = function (args, optionsOrCb, cb) {
-        var command = new DeleteMediaCapturePipelineCommand(args);
+    }
+    deleteMediaCapturePipeline(args, optionsOrCb, cb) {
+        const command = new DeleteMediaCapturePipelineCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteMeeting = function (args, optionsOrCb, cb) {
-        var command = new DeleteMeetingCommand(args);
+    }
+    deleteMeeting(args, optionsOrCb, cb) {
+        const command = new DeleteMeetingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deletePhoneNumber = function (args, optionsOrCb, cb) {
-        var command = new DeletePhoneNumberCommand(args);
+    }
+    deletePhoneNumber(args, optionsOrCb, cb) {
+        const command = new DeletePhoneNumberCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteProxySession = function (args, optionsOrCb, cb) {
-        var command = new DeleteProxySessionCommand(args);
+    }
+    deleteProxySession(args, optionsOrCb, cb) {
+        const command = new DeleteProxySessionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteRoom = function (args, optionsOrCb, cb) {
-        var command = new DeleteRoomCommand(args);
+    }
+    deleteRoom(args, optionsOrCb, cb) {
+        const command = new DeleteRoomCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteRoomMembership = function (args, optionsOrCb, cb) {
-        var command = new DeleteRoomMembershipCommand(args);
+    }
+    deleteRoomMembership(args, optionsOrCb, cb) {
+        const command = new DeleteRoomMembershipCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteSipMediaApplication = function (args, optionsOrCb, cb) {
-        var command = new DeleteSipMediaApplicationCommand(args);
+    }
+    deleteSipMediaApplication(args, optionsOrCb, cb) {
+        const command = new DeleteSipMediaApplicationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteSipRule = function (args, optionsOrCb, cb) {
-        var command = new DeleteSipRuleCommand(args);
+    }
+    deleteSipRule(args, optionsOrCb, cb) {
+        const command = new DeleteSipRuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteVoiceConnector = function (args, optionsOrCb, cb) {
-        var command = new DeleteVoiceConnectorCommand(args);
+    }
+    deleteVoiceConnector(args, optionsOrCb, cb) {
+        const command = new DeleteVoiceConnectorCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteVoiceConnectorEmergencyCallingConfiguration = function (args, optionsOrCb, cb) {
-        var command = new DeleteVoiceConnectorEmergencyCallingConfigurationCommand(args);
+    }
+    deleteVoiceConnectorEmergencyCallingConfiguration(args, optionsOrCb, cb) {
+        const command = new DeleteVoiceConnectorEmergencyCallingConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteVoiceConnectorGroup = function (args, optionsOrCb, cb) {
-        var command = new DeleteVoiceConnectorGroupCommand(args);
+    }
+    deleteVoiceConnectorGroup(args, optionsOrCb, cb) {
+        const command = new DeleteVoiceConnectorGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteVoiceConnectorOrigination = function (args, optionsOrCb, cb) {
-        var command = new DeleteVoiceConnectorOriginationCommand(args);
+    }
+    deleteVoiceConnectorOrigination(args, optionsOrCb, cb) {
+        const command = new DeleteVoiceConnectorOriginationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteVoiceConnectorProxy = function (args, optionsOrCb, cb) {
-        var command = new DeleteVoiceConnectorProxyCommand(args);
+    }
+    deleteVoiceConnectorProxy(args, optionsOrCb, cb) {
+        const command = new DeleteVoiceConnectorProxyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteVoiceConnectorStreamingConfiguration = function (args, optionsOrCb, cb) {
-        var command = new DeleteVoiceConnectorStreamingConfigurationCommand(args);
+    }
+    deleteVoiceConnectorStreamingConfiguration(args, optionsOrCb, cb) {
+        const command = new DeleteVoiceConnectorStreamingConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteVoiceConnectorTermination = function (args, optionsOrCb, cb) {
-        var command = new DeleteVoiceConnectorTerminationCommand(args);
+    }
+    deleteVoiceConnectorTermination(args, optionsOrCb, cb) {
+        const command = new DeleteVoiceConnectorTerminationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.deleteVoiceConnectorTerminationCredentials = function (args, optionsOrCb, cb) {
-        var command = new DeleteVoiceConnectorTerminationCredentialsCommand(args);
+    }
+    deleteVoiceConnectorTerminationCredentials(args, optionsOrCb, cb) {
+        const command = new DeleteVoiceConnectorTerminationCredentialsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.describeAppInstance = function (args, optionsOrCb, cb) {
-        var command = new DescribeAppInstanceCommand(args);
+    }
+    describeAppInstance(args, optionsOrCb, cb) {
+        const command = new DescribeAppInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.describeAppInstanceAdmin = function (args, optionsOrCb, cb) {
-        var command = new DescribeAppInstanceAdminCommand(args);
+    }
+    describeAppInstanceAdmin(args, optionsOrCb, cb) {
+        const command = new DescribeAppInstanceAdminCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.describeAppInstanceUser = function (args, optionsOrCb, cb) {
-        var command = new DescribeAppInstanceUserCommand(args);
+    }
+    describeAppInstanceUser(args, optionsOrCb, cb) {
+        const command = new DescribeAppInstanceUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.describeChannel = function (args, optionsOrCb, cb) {
-        var command = new DescribeChannelCommand(args);
+    }
+    describeChannel(args, optionsOrCb, cb) {
+        const command = new DescribeChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.describeChannelBan = function (args, optionsOrCb, cb) {
-        var command = new DescribeChannelBanCommand(args);
+    }
+    describeChannelBan(args, optionsOrCb, cb) {
+        const command = new DescribeChannelBanCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.describeChannelMembership = function (args, optionsOrCb, cb) {
-        var command = new DescribeChannelMembershipCommand(args);
+    }
+    describeChannelMembership(args, optionsOrCb, cb) {
+        const command = new DescribeChannelMembershipCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.describeChannelMembershipForAppInstanceUser = function (args, optionsOrCb, cb) {
-        var command = new DescribeChannelMembershipForAppInstanceUserCommand(args);
+    }
+    describeChannelMembershipForAppInstanceUser(args, optionsOrCb, cb) {
+        const command = new DescribeChannelMembershipForAppInstanceUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.describeChannelModeratedByAppInstanceUser = function (args, optionsOrCb, cb) {
-        var command = new DescribeChannelModeratedByAppInstanceUserCommand(args);
+    }
+    describeChannelModeratedByAppInstanceUser(args, optionsOrCb, cb) {
+        const command = new DescribeChannelModeratedByAppInstanceUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.describeChannelModerator = function (args, optionsOrCb, cb) {
-        var command = new DescribeChannelModeratorCommand(args);
+    }
+    describeChannelModerator(args, optionsOrCb, cb) {
+        const command = new DescribeChannelModeratorCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.disassociatePhoneNumberFromUser = function (args, optionsOrCb, cb) {
-        var command = new DisassociatePhoneNumberFromUserCommand(args);
+    }
+    disassociatePhoneNumberFromUser(args, optionsOrCb, cb) {
+        const command = new DisassociatePhoneNumberFromUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.disassociatePhoneNumbersFromVoiceConnector = function (args, optionsOrCb, cb) {
-        var command = new DisassociatePhoneNumbersFromVoiceConnectorCommand(args);
+    }
+    disassociatePhoneNumbersFromVoiceConnector(args, optionsOrCb, cb) {
+        const command = new DisassociatePhoneNumbersFromVoiceConnectorCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.disassociatePhoneNumbersFromVoiceConnectorGroup = function (args, optionsOrCb, cb) {
-        var command = new DisassociatePhoneNumbersFromVoiceConnectorGroupCommand(args);
+    }
+    disassociatePhoneNumbersFromVoiceConnectorGroup(args, optionsOrCb, cb) {
+        const command = new DisassociatePhoneNumbersFromVoiceConnectorGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.disassociateSigninDelegateGroupsFromAccount = function (args, optionsOrCb, cb) {
-        var command = new DisassociateSigninDelegateGroupsFromAccountCommand(args);
+    }
+    disassociateSigninDelegateGroupsFromAccount(args, optionsOrCb, cb) {
+        const command = new DisassociateSigninDelegateGroupsFromAccountCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getAccount = function (args, optionsOrCb, cb) {
-        var command = new GetAccountCommand(args);
+    }
+    getAccount(args, optionsOrCb, cb) {
+        const command = new GetAccountCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getAccountSettings = function (args, optionsOrCb, cb) {
-        var command = new GetAccountSettingsCommand(args);
+    }
+    getAccountSettings(args, optionsOrCb, cb) {
+        const command = new GetAccountSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getAppInstanceRetentionSettings = function (args, optionsOrCb, cb) {
-        var command = new GetAppInstanceRetentionSettingsCommand(args);
+    }
+    getAppInstanceRetentionSettings(args, optionsOrCb, cb) {
+        const command = new GetAppInstanceRetentionSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getAppInstanceStreamingConfigurations = function (args, optionsOrCb, cb) {
-        var command = new GetAppInstanceStreamingConfigurationsCommand(args);
+    }
+    getAppInstanceStreamingConfigurations(args, optionsOrCb, cb) {
+        const command = new GetAppInstanceStreamingConfigurationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getAttendee = function (args, optionsOrCb, cb) {
-        var command = new GetAttendeeCommand(args);
+    }
+    getAttendee(args, optionsOrCb, cb) {
+        const command = new GetAttendeeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getBot = function (args, optionsOrCb, cb) {
-        var command = new GetBotCommand(args);
+    }
+    getBot(args, optionsOrCb, cb) {
+        const command = new GetBotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getChannelMessage = function (args, optionsOrCb, cb) {
-        var command = new GetChannelMessageCommand(args);
+    }
+    getChannelMessage(args, optionsOrCb, cb) {
+        const command = new GetChannelMessageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getEventsConfiguration = function (args, optionsOrCb, cb) {
-        var command = new GetEventsConfigurationCommand(args);
+    }
+    getEventsConfiguration(args, optionsOrCb, cb) {
+        const command = new GetEventsConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getGlobalSettings = function (args, optionsOrCb, cb) {
-        var command = new GetGlobalSettingsCommand(args);
+    }
+    getGlobalSettings(args, optionsOrCb, cb) {
+        const command = new GetGlobalSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getMediaCapturePipeline = function (args, optionsOrCb, cb) {
-        var command = new GetMediaCapturePipelineCommand(args);
+    }
+    getMediaCapturePipeline(args, optionsOrCb, cb) {
+        const command = new GetMediaCapturePipelineCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getMeeting = function (args, optionsOrCb, cb) {
-        var command = new GetMeetingCommand(args);
+    }
+    getMeeting(args, optionsOrCb, cb) {
+        const command = new GetMeetingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getMessagingSessionEndpoint = function (args, optionsOrCb, cb) {
-        var command = new GetMessagingSessionEndpointCommand(args);
+    }
+    getMessagingSessionEndpoint(args, optionsOrCb, cb) {
+        const command = new GetMessagingSessionEndpointCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getPhoneNumber = function (args, optionsOrCb, cb) {
-        var command = new GetPhoneNumberCommand(args);
+    }
+    getPhoneNumber(args, optionsOrCb, cb) {
+        const command = new GetPhoneNumberCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getPhoneNumberOrder = function (args, optionsOrCb, cb) {
-        var command = new GetPhoneNumberOrderCommand(args);
+    }
+    getPhoneNumberOrder(args, optionsOrCb, cb) {
+        const command = new GetPhoneNumberOrderCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getPhoneNumberSettings = function (args, optionsOrCb, cb) {
-        var command = new GetPhoneNumberSettingsCommand(args);
+    }
+    getPhoneNumberSettings(args, optionsOrCb, cb) {
+        const command = new GetPhoneNumberSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getProxySession = function (args, optionsOrCb, cb) {
-        var command = new GetProxySessionCommand(args);
+    }
+    getProxySession(args, optionsOrCb, cb) {
+        const command = new GetProxySessionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getRetentionSettings = function (args, optionsOrCb, cb) {
-        var command = new GetRetentionSettingsCommand(args);
+    }
+    getRetentionSettings(args, optionsOrCb, cb) {
+        const command = new GetRetentionSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getRoom = function (args, optionsOrCb, cb) {
-        var command = new GetRoomCommand(args);
+    }
+    getRoom(args, optionsOrCb, cb) {
+        const command = new GetRoomCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getSipMediaApplication = function (args, optionsOrCb, cb) {
-        var command = new GetSipMediaApplicationCommand(args);
+    }
+    getSipMediaApplication(args, optionsOrCb, cb) {
+        const command = new GetSipMediaApplicationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getSipMediaApplicationLoggingConfiguration = function (args, optionsOrCb, cb) {
-        var command = new GetSipMediaApplicationLoggingConfigurationCommand(args);
+    }
+    getSipMediaApplicationLoggingConfiguration(args, optionsOrCb, cb) {
+        const command = new GetSipMediaApplicationLoggingConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getSipRule = function (args, optionsOrCb, cb) {
-        var command = new GetSipRuleCommand(args);
+    }
+    getSipRule(args, optionsOrCb, cb) {
+        const command = new GetSipRuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getUser = function (args, optionsOrCb, cb) {
-        var command = new GetUserCommand(args);
+    }
+    getUser(args, optionsOrCb, cb) {
+        const command = new GetUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getUserSettings = function (args, optionsOrCb, cb) {
-        var command = new GetUserSettingsCommand(args);
+    }
+    getUserSettings(args, optionsOrCb, cb) {
+        const command = new GetUserSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getVoiceConnector = function (args, optionsOrCb, cb) {
-        var command = new GetVoiceConnectorCommand(args);
+    }
+    getVoiceConnector(args, optionsOrCb, cb) {
+        const command = new GetVoiceConnectorCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getVoiceConnectorEmergencyCallingConfiguration = function (args, optionsOrCb, cb) {
-        var command = new GetVoiceConnectorEmergencyCallingConfigurationCommand(args);
+    }
+    getVoiceConnectorEmergencyCallingConfiguration(args, optionsOrCb, cb) {
+        const command = new GetVoiceConnectorEmergencyCallingConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getVoiceConnectorGroup = function (args, optionsOrCb, cb) {
-        var command = new GetVoiceConnectorGroupCommand(args);
+    }
+    getVoiceConnectorGroup(args, optionsOrCb, cb) {
+        const command = new GetVoiceConnectorGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getVoiceConnectorLoggingConfiguration = function (args, optionsOrCb, cb) {
-        var command = new GetVoiceConnectorLoggingConfigurationCommand(args);
+    }
+    getVoiceConnectorLoggingConfiguration(args, optionsOrCb, cb) {
+        const command = new GetVoiceConnectorLoggingConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getVoiceConnectorOrigination = function (args, optionsOrCb, cb) {
-        var command = new GetVoiceConnectorOriginationCommand(args);
+    }
+    getVoiceConnectorOrigination(args, optionsOrCb, cb) {
+        const command = new GetVoiceConnectorOriginationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getVoiceConnectorProxy = function (args, optionsOrCb, cb) {
-        var command = new GetVoiceConnectorProxyCommand(args);
+    }
+    getVoiceConnectorProxy(args, optionsOrCb, cb) {
+        const command = new GetVoiceConnectorProxyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getVoiceConnectorStreamingConfiguration = function (args, optionsOrCb, cb) {
-        var command = new GetVoiceConnectorStreamingConfigurationCommand(args);
+    }
+    getVoiceConnectorStreamingConfiguration(args, optionsOrCb, cb) {
+        const command = new GetVoiceConnectorStreamingConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getVoiceConnectorTermination = function (args, optionsOrCb, cb) {
-        var command = new GetVoiceConnectorTerminationCommand(args);
+    }
+    getVoiceConnectorTermination(args, optionsOrCb, cb) {
+        const command = new GetVoiceConnectorTerminationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.getVoiceConnectorTerminationHealth = function (args, optionsOrCb, cb) {
-        var command = new GetVoiceConnectorTerminationHealthCommand(args);
+    }
+    getVoiceConnectorTerminationHealth(args, optionsOrCb, cb) {
+        const command = new GetVoiceConnectorTerminationHealthCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.inviteUsers = function (args, optionsOrCb, cb) {
-        var command = new InviteUsersCommand(args);
+    }
+    inviteUsers(args, optionsOrCb, cb) {
+        const command = new InviteUsersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listAccounts = function (args, optionsOrCb, cb) {
-        var command = new ListAccountsCommand(args);
+    }
+    listAccounts(args, optionsOrCb, cb) {
+        const command = new ListAccountsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listAppInstanceAdmins = function (args, optionsOrCb, cb) {
-        var command = new ListAppInstanceAdminsCommand(args);
+    }
+    listAppInstanceAdmins(args, optionsOrCb, cb) {
+        const command = new ListAppInstanceAdminsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listAppInstances = function (args, optionsOrCb, cb) {
-        var command = new ListAppInstancesCommand(args);
+    }
+    listAppInstances(args, optionsOrCb, cb) {
+        const command = new ListAppInstancesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listAppInstanceUsers = function (args, optionsOrCb, cb) {
-        var command = new ListAppInstanceUsersCommand(args);
+    }
+    listAppInstanceUsers(args, optionsOrCb, cb) {
+        const command = new ListAppInstanceUsersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listAttendees = function (args, optionsOrCb, cb) {
-        var command = new ListAttendeesCommand(args);
+    }
+    listAttendees(args, optionsOrCb, cb) {
+        const command = new ListAttendeesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listAttendeeTags = function (args, optionsOrCb, cb) {
-        var command = new ListAttendeeTagsCommand(args);
+    }
+    listAttendeeTags(args, optionsOrCb, cb) {
+        const command = new ListAttendeeTagsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listBots = function (args, optionsOrCb, cb) {
-        var command = new ListBotsCommand(args);
+    }
+    listBots(args, optionsOrCb, cb) {
+        const command = new ListBotsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listChannelBans = function (args, optionsOrCb, cb) {
-        var command = new ListChannelBansCommand(args);
+    }
+    listChannelBans(args, optionsOrCb, cb) {
+        const command = new ListChannelBansCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listChannelMemberships = function (args, optionsOrCb, cb) {
-        var command = new ListChannelMembershipsCommand(args);
+    }
+    listChannelMemberships(args, optionsOrCb, cb) {
+        const command = new ListChannelMembershipsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listChannelMembershipsForAppInstanceUser = function (args, optionsOrCb, cb) {
-        var command = new ListChannelMembershipsForAppInstanceUserCommand(args);
+    }
+    listChannelMembershipsForAppInstanceUser(args, optionsOrCb, cb) {
+        const command = new ListChannelMembershipsForAppInstanceUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listChannelMessages = function (args, optionsOrCb, cb) {
-        var command = new ListChannelMessagesCommand(args);
+    }
+    listChannelMessages(args, optionsOrCb, cb) {
+        const command = new ListChannelMessagesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listChannelModerators = function (args, optionsOrCb, cb) {
-        var command = new ListChannelModeratorsCommand(args);
+    }
+    listChannelModerators(args, optionsOrCb, cb) {
+        const command = new ListChannelModeratorsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listChannels = function (args, optionsOrCb, cb) {
-        var command = new ListChannelsCommand(args);
+    }
+    listChannels(args, optionsOrCb, cb) {
+        const command = new ListChannelsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listChannelsModeratedByAppInstanceUser = function (args, optionsOrCb, cb) {
-        var command = new ListChannelsModeratedByAppInstanceUserCommand(args);
+    }
+    listChannelsModeratedByAppInstanceUser(args, optionsOrCb, cb) {
+        const command = new ListChannelsModeratedByAppInstanceUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listMediaCapturePipelines = function (args, optionsOrCb, cb) {
-        var command = new ListMediaCapturePipelinesCommand(args);
+    }
+    listMediaCapturePipelines(args, optionsOrCb, cb) {
+        const command = new ListMediaCapturePipelinesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listMeetings = function (args, optionsOrCb, cb) {
-        var command = new ListMeetingsCommand(args);
+    }
+    listMeetings(args, optionsOrCb, cb) {
+        const command = new ListMeetingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listMeetingTags = function (args, optionsOrCb, cb) {
-        var command = new ListMeetingTagsCommand(args);
+    }
+    listMeetingTags(args, optionsOrCb, cb) {
+        const command = new ListMeetingTagsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listPhoneNumberOrders = function (args, optionsOrCb, cb) {
-        var command = new ListPhoneNumberOrdersCommand(args);
+    }
+    listPhoneNumberOrders(args, optionsOrCb, cb) {
+        const command = new ListPhoneNumberOrdersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listPhoneNumbers = function (args, optionsOrCb, cb) {
-        var command = new ListPhoneNumbersCommand(args);
+    }
+    listPhoneNumbers(args, optionsOrCb, cb) {
+        const command = new ListPhoneNumbersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listProxySessions = function (args, optionsOrCb, cb) {
-        var command = new ListProxySessionsCommand(args);
+    }
+    listProxySessions(args, optionsOrCb, cb) {
+        const command = new ListProxySessionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listRoomMemberships = function (args, optionsOrCb, cb) {
-        var command = new ListRoomMembershipsCommand(args);
+    }
+    listRoomMemberships(args, optionsOrCb, cb) {
+        const command = new ListRoomMembershipsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listRooms = function (args, optionsOrCb, cb) {
-        var command = new ListRoomsCommand(args);
+    }
+    listRooms(args, optionsOrCb, cb) {
+        const command = new ListRoomsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listSipMediaApplications = function (args, optionsOrCb, cb) {
-        var command = new ListSipMediaApplicationsCommand(args);
+    }
+    listSipMediaApplications(args, optionsOrCb, cb) {
+        const command = new ListSipMediaApplicationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listSipRules = function (args, optionsOrCb, cb) {
-        var command = new ListSipRulesCommand(args);
+    }
+    listSipRules(args, optionsOrCb, cb) {
+        const command = new ListSipRulesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listSupportedPhoneNumberCountries = function (args, optionsOrCb, cb) {
-        var command = new ListSupportedPhoneNumberCountriesCommand(args);
+    }
+    listSupportedPhoneNumberCountries(args, optionsOrCb, cb) {
+        const command = new ListSupportedPhoneNumberCountriesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listTagsForResource = function (args, optionsOrCb, cb) {
-        var command = new ListTagsForResourceCommand(args);
+    }
+    listTagsForResource(args, optionsOrCb, cb) {
+        const command = new ListTagsForResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listUsers = function (args, optionsOrCb, cb) {
-        var command = new ListUsersCommand(args);
+    }
+    listUsers(args, optionsOrCb, cb) {
+        const command = new ListUsersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listVoiceConnectorGroups = function (args, optionsOrCb, cb) {
-        var command = new ListVoiceConnectorGroupsCommand(args);
+    }
+    listVoiceConnectorGroups(args, optionsOrCb, cb) {
+        const command = new ListVoiceConnectorGroupsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listVoiceConnectors = function (args, optionsOrCb, cb) {
-        var command = new ListVoiceConnectorsCommand(args);
+    }
+    listVoiceConnectors(args, optionsOrCb, cb) {
+        const command = new ListVoiceConnectorsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.listVoiceConnectorTerminationCredentials = function (args, optionsOrCb, cb) {
-        var command = new ListVoiceConnectorTerminationCredentialsCommand(args);
+    }
+    listVoiceConnectorTerminationCredentials(args, optionsOrCb, cb) {
+        const command = new ListVoiceConnectorTerminationCredentialsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.logoutUser = function (args, optionsOrCb, cb) {
-        var command = new LogoutUserCommand(args);
+    }
+    logoutUser(args, optionsOrCb, cb) {
+        const command = new LogoutUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.putAppInstanceRetentionSettings = function (args, optionsOrCb, cb) {
-        var command = new PutAppInstanceRetentionSettingsCommand(args);
+    }
+    putAppInstanceRetentionSettings(args, optionsOrCb, cb) {
+        const command = new PutAppInstanceRetentionSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.putAppInstanceStreamingConfigurations = function (args, optionsOrCb, cb) {
-        var command = new PutAppInstanceStreamingConfigurationsCommand(args);
+    }
+    putAppInstanceStreamingConfigurations(args, optionsOrCb, cb) {
+        const command = new PutAppInstanceStreamingConfigurationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.putEventsConfiguration = function (args, optionsOrCb, cb) {
-        var command = new PutEventsConfigurationCommand(args);
+    }
+    putEventsConfiguration(args, optionsOrCb, cb) {
+        const command = new PutEventsConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.putRetentionSettings = function (args, optionsOrCb, cb) {
-        var command = new PutRetentionSettingsCommand(args);
+    }
+    putRetentionSettings(args, optionsOrCb, cb) {
+        const command = new PutRetentionSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.putSipMediaApplicationLoggingConfiguration = function (args, optionsOrCb, cb) {
-        var command = new PutSipMediaApplicationLoggingConfigurationCommand(args);
+    }
+    putSipMediaApplicationLoggingConfiguration(args, optionsOrCb, cb) {
+        const command = new PutSipMediaApplicationLoggingConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.putVoiceConnectorEmergencyCallingConfiguration = function (args, optionsOrCb, cb) {
-        var command = new PutVoiceConnectorEmergencyCallingConfigurationCommand(args);
+    }
+    putVoiceConnectorEmergencyCallingConfiguration(args, optionsOrCb, cb) {
+        const command = new PutVoiceConnectorEmergencyCallingConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.putVoiceConnectorLoggingConfiguration = function (args, optionsOrCb, cb) {
-        var command = new PutVoiceConnectorLoggingConfigurationCommand(args);
+    }
+    putVoiceConnectorLoggingConfiguration(args, optionsOrCb, cb) {
+        const command = new PutVoiceConnectorLoggingConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.putVoiceConnectorOrigination = function (args, optionsOrCb, cb) {
-        var command = new PutVoiceConnectorOriginationCommand(args);
+    }
+    putVoiceConnectorOrigination(args, optionsOrCb, cb) {
+        const command = new PutVoiceConnectorOriginationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.putVoiceConnectorProxy = function (args, optionsOrCb, cb) {
-        var command = new PutVoiceConnectorProxyCommand(args);
+    }
+    putVoiceConnectorProxy(args, optionsOrCb, cb) {
+        const command = new PutVoiceConnectorProxyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.putVoiceConnectorStreamingConfiguration = function (args, optionsOrCb, cb) {
-        var command = new PutVoiceConnectorStreamingConfigurationCommand(args);
+    }
+    putVoiceConnectorStreamingConfiguration(args, optionsOrCb, cb) {
+        const command = new PutVoiceConnectorStreamingConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.putVoiceConnectorTermination = function (args, optionsOrCb, cb) {
-        var command = new PutVoiceConnectorTerminationCommand(args);
+    }
+    putVoiceConnectorTermination(args, optionsOrCb, cb) {
+        const command = new PutVoiceConnectorTerminationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.putVoiceConnectorTerminationCredentials = function (args, optionsOrCb, cb) {
-        var command = new PutVoiceConnectorTerminationCredentialsCommand(args);
+    }
+    putVoiceConnectorTerminationCredentials(args, optionsOrCb, cb) {
+        const command = new PutVoiceConnectorTerminationCredentialsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.redactChannelMessage = function (args, optionsOrCb, cb) {
-        var command = new RedactChannelMessageCommand(args);
+    }
+    redactChannelMessage(args, optionsOrCb, cb) {
+        const command = new RedactChannelMessageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.redactConversationMessage = function (args, optionsOrCb, cb) {
-        var command = new RedactConversationMessageCommand(args);
+    }
+    redactConversationMessage(args, optionsOrCb, cb) {
+        const command = new RedactConversationMessageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.redactRoomMessage = function (args, optionsOrCb, cb) {
-        var command = new RedactRoomMessageCommand(args);
+    }
+    redactRoomMessage(args, optionsOrCb, cb) {
+        const command = new RedactRoomMessageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.regenerateSecurityToken = function (args, optionsOrCb, cb) {
-        var command = new RegenerateSecurityTokenCommand(args);
+    }
+    regenerateSecurityToken(args, optionsOrCb, cb) {
+        const command = new RegenerateSecurityTokenCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.resetPersonalPIN = function (args, optionsOrCb, cb) {
-        var command = new ResetPersonalPINCommand(args);
+    }
+    resetPersonalPIN(args, optionsOrCb, cb) {
+        const command = new ResetPersonalPINCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.restorePhoneNumber = function (args, optionsOrCb, cb) {
-        var command = new RestorePhoneNumberCommand(args);
+    }
+    restorePhoneNumber(args, optionsOrCb, cb) {
+        const command = new RestorePhoneNumberCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.searchAvailablePhoneNumbers = function (args, optionsOrCb, cb) {
-        var command = new SearchAvailablePhoneNumbersCommand(args);
+    }
+    searchAvailablePhoneNumbers(args, optionsOrCb, cb) {
+        const command = new SearchAvailablePhoneNumbersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.sendChannelMessage = function (args, optionsOrCb, cb) {
-        var command = new SendChannelMessageCommand(args);
+    }
+    sendChannelMessage(args, optionsOrCb, cb) {
+        const command = new SendChannelMessageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.startMeetingTranscription = function (args, optionsOrCb, cb) {
-        var command = new StartMeetingTranscriptionCommand(args);
+    }
+    startMeetingTranscription(args, optionsOrCb, cb) {
+        const command = new StartMeetingTranscriptionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.stopMeetingTranscription = function (args, optionsOrCb, cb) {
-        var command = new StopMeetingTranscriptionCommand(args);
+    }
+    stopMeetingTranscription(args, optionsOrCb, cb) {
+        const command = new StopMeetingTranscriptionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.tagAttendee = function (args, optionsOrCb, cb) {
-        var command = new TagAttendeeCommand(args);
+    }
+    tagAttendee(args, optionsOrCb, cb) {
+        const command = new TagAttendeeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.tagMeeting = function (args, optionsOrCb, cb) {
-        var command = new TagMeetingCommand(args);
+    }
+    tagMeeting(args, optionsOrCb, cb) {
+        const command = new TagMeetingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.tagResource = function (args, optionsOrCb, cb) {
-        var command = new TagResourceCommand(args);
+    }
+    tagResource(args, optionsOrCb, cb) {
+        const command = new TagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.untagAttendee = function (args, optionsOrCb, cb) {
-        var command = new UntagAttendeeCommand(args);
+    }
+    untagAttendee(args, optionsOrCb, cb) {
+        const command = new UntagAttendeeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.untagMeeting = function (args, optionsOrCb, cb) {
-        var command = new UntagMeetingCommand(args);
+    }
+    untagMeeting(args, optionsOrCb, cb) {
+        const command = new UntagMeetingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.untagResource = function (args, optionsOrCb, cb) {
-        var command = new UntagResourceCommand(args);
+    }
+    untagResource(args, optionsOrCb, cb) {
+        const command = new UntagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.updateAccount = function (args, optionsOrCb, cb) {
-        var command = new UpdateAccountCommand(args);
+    }
+    updateAccount(args, optionsOrCb, cb) {
+        const command = new UpdateAccountCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.updateAccountSettings = function (args, optionsOrCb, cb) {
-        var command = new UpdateAccountSettingsCommand(args);
+    }
+    updateAccountSettings(args, optionsOrCb, cb) {
+        const command = new UpdateAccountSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.updateAppInstance = function (args, optionsOrCb, cb) {
-        var command = new UpdateAppInstanceCommand(args);
+    }
+    updateAppInstance(args, optionsOrCb, cb) {
+        const command = new UpdateAppInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.updateAppInstanceUser = function (args, optionsOrCb, cb) {
-        var command = new UpdateAppInstanceUserCommand(args);
+    }
+    updateAppInstanceUser(args, optionsOrCb, cb) {
+        const command = new UpdateAppInstanceUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.updateBot = function (args, optionsOrCb, cb) {
-        var command = new UpdateBotCommand(args);
+    }
+    updateBot(args, optionsOrCb, cb) {
+        const command = new UpdateBotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.updateChannel = function (args, optionsOrCb, cb) {
-        var command = new UpdateChannelCommand(args);
+    }
+    updateChannel(args, optionsOrCb, cb) {
+        const command = new UpdateChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.updateChannelMessage = function (args, optionsOrCb, cb) {
-        var command = new UpdateChannelMessageCommand(args);
+    }
+    updateChannelMessage(args, optionsOrCb, cb) {
+        const command = new UpdateChannelMessageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.updateChannelReadMarker = function (args, optionsOrCb, cb) {
-        var command = new UpdateChannelReadMarkerCommand(args);
+    }
+    updateChannelReadMarker(args, optionsOrCb, cb) {
+        const command = new UpdateChannelReadMarkerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.updateGlobalSettings = function (args, optionsOrCb, cb) {
-        var command = new UpdateGlobalSettingsCommand(args);
+    }
+    updateGlobalSettings(args, optionsOrCb, cb) {
+        const command = new UpdateGlobalSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.updatePhoneNumber = function (args, optionsOrCb, cb) {
-        var command = new UpdatePhoneNumberCommand(args);
+    }
+    updatePhoneNumber(args, optionsOrCb, cb) {
+        const command = new UpdatePhoneNumberCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.updatePhoneNumberSettings = function (args, optionsOrCb, cb) {
-        var command = new UpdatePhoneNumberSettingsCommand(args);
+    }
+    updatePhoneNumberSettings(args, optionsOrCb, cb) {
+        const command = new UpdatePhoneNumberSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.updateProxySession = function (args, optionsOrCb, cb) {
-        var command = new UpdateProxySessionCommand(args);
+    }
+    updateProxySession(args, optionsOrCb, cb) {
+        const command = new UpdateProxySessionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.updateRoom = function (args, optionsOrCb, cb) {
-        var command = new UpdateRoomCommand(args);
+    }
+    updateRoom(args, optionsOrCb, cb) {
+        const command = new UpdateRoomCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.updateRoomMembership = function (args, optionsOrCb, cb) {
-        var command = new UpdateRoomMembershipCommand(args);
+    }
+    updateRoomMembership(args, optionsOrCb, cb) {
+        const command = new UpdateRoomMembershipCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.updateSipMediaApplication = function (args, optionsOrCb, cb) {
-        var command = new UpdateSipMediaApplicationCommand(args);
+    }
+    updateSipMediaApplication(args, optionsOrCb, cb) {
+        const command = new UpdateSipMediaApplicationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.updateSipMediaApplicationCall = function (args, optionsOrCb, cb) {
-        var command = new UpdateSipMediaApplicationCallCommand(args);
+    }
+    updateSipMediaApplicationCall(args, optionsOrCb, cb) {
+        const command = new UpdateSipMediaApplicationCallCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.updateSipRule = function (args, optionsOrCb, cb) {
-        var command = new UpdateSipRuleCommand(args);
+    }
+    updateSipRule(args, optionsOrCb, cb) {
+        const command = new UpdateSipRuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.updateUser = function (args, optionsOrCb, cb) {
-        var command = new UpdateUserCommand(args);
+    }
+    updateUser(args, optionsOrCb, cb) {
+        const command = new UpdateUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.updateUserSettings = function (args, optionsOrCb, cb) {
-        var command = new UpdateUserSettingsCommand(args);
+    }
+    updateUserSettings(args, optionsOrCb, cb) {
+        const command = new UpdateUserSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.updateVoiceConnector = function (args, optionsOrCb, cb) {
-        var command = new UpdateVoiceConnectorCommand(args);
+    }
+    updateVoiceConnector(args, optionsOrCb, cb) {
+        const command = new UpdateVoiceConnectorCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.updateVoiceConnectorGroup = function (args, optionsOrCb, cb) {
-        var command = new UpdateVoiceConnectorGroupCommand(args);
+    }
+    updateVoiceConnectorGroup(args, optionsOrCb, cb) {
+        const command = new UpdateVoiceConnectorGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Chime.prototype.validateE911Address = function (args, optionsOrCb, cb) {
-        var command = new ValidateE911AddressCommand(args);
+    }
+    validateE911Address(args, optionsOrCb, cb) {
+        const command = new ValidateE911AddressCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    return Chime;
-}(ChimeClient));
-export { Chime };
+    }
+}