@aws-sdk/client-chime 3.183.0 → 3.185.0

package/dist-es/Chime.js

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