@aws-sdk/client-connect 3.181.0 → 3.184.0

package/dist-es/Connect.js

@@ -1,4 +1,3 @@
-import { __extends } from "tslib";
 import { AssociateApprovedOriginCommand, } from "./commands/AssociateApprovedOriginCommand";
 import { AssociateBotCommand, } from "./commands/AssociateBotCommand";
 import { AssociateDefaultVocabularyCommand, } from "./commands/AssociateDefaultVocabularyCommand";
@@ -154,2167 +153,2161 @@ import { UpdateUserPhoneConfigCommand, } from "./commands/UpdateUserPhoneConfigC
 import { UpdateUserRoutingProfileCommand, } from "./commands/UpdateUserRoutingProfileCommand";
 import { UpdateUserSecurityProfilesCommand, } from "./commands/UpdateUserSecurityProfilesCommand";
 import { ConnectClient } from "./ConnectClient";
-var Connect = (function (_super) {
-    __extends(Connect, _super);
-    function Connect() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    Connect.prototype.associateApprovedOrigin = function (args, optionsOrCb, cb) {
-        var command = new AssociateApprovedOriginCommand(args);
+export class Connect extends ConnectClient {
+    associateApprovedOrigin(args, optionsOrCb, cb) {
+        const command = new AssociateApprovedOriginCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.associateBot = function (args, optionsOrCb, cb) {
-        var command = new AssociateBotCommand(args);
+    }
+    associateBot(args, optionsOrCb, cb) {
+        const command = new AssociateBotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.associateDefaultVocabulary = function (args, optionsOrCb, cb) {
-        var command = new AssociateDefaultVocabularyCommand(args);
+    }
+    associateDefaultVocabulary(args, optionsOrCb, cb) {
+        const command = new AssociateDefaultVocabularyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.associateInstanceStorageConfig = function (args, optionsOrCb, cb) {
-        var command = new AssociateInstanceStorageConfigCommand(args);
+    }
+    associateInstanceStorageConfig(args, optionsOrCb, cb) {
+        const command = new AssociateInstanceStorageConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.associateLambdaFunction = function (args, optionsOrCb, cb) {
-        var command = new AssociateLambdaFunctionCommand(args);
+    }
+    associateLambdaFunction(args, optionsOrCb, cb) {
+        const command = new AssociateLambdaFunctionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.associateLexBot = function (args, optionsOrCb, cb) {
-        var command = new AssociateLexBotCommand(args);
+    }
+    associateLexBot(args, optionsOrCb, cb) {
+        const command = new AssociateLexBotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.associatePhoneNumberContactFlow = function (args, optionsOrCb, cb) {
-        var command = new AssociatePhoneNumberContactFlowCommand(args);
+    }
+    associatePhoneNumberContactFlow(args, optionsOrCb, cb) {
+        const command = new AssociatePhoneNumberContactFlowCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.associateQueueQuickConnects = function (args, optionsOrCb, cb) {
-        var command = new AssociateQueueQuickConnectsCommand(args);
+    }
+    associateQueueQuickConnects(args, optionsOrCb, cb) {
+        const command = new AssociateQueueQuickConnectsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.associateRoutingProfileQueues = function (args, optionsOrCb, cb) {
-        var command = new AssociateRoutingProfileQueuesCommand(args);
+    }
+    associateRoutingProfileQueues(args, optionsOrCb, cb) {
+        const command = new AssociateRoutingProfileQueuesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.associateSecurityKey = function (args, optionsOrCb, cb) {
-        var command = new AssociateSecurityKeyCommand(args);
+    }
+    associateSecurityKey(args, optionsOrCb, cb) {
+        const command = new AssociateSecurityKeyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.claimPhoneNumber = function (args, optionsOrCb, cb) {
-        var command = new ClaimPhoneNumberCommand(args);
+    }
+    claimPhoneNumber(args, optionsOrCb, cb) {
+        const command = new ClaimPhoneNumberCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.createAgentStatus = function (args, optionsOrCb, cb) {
-        var command = new CreateAgentStatusCommand(args);
+    }
+    createAgentStatus(args, optionsOrCb, cb) {
+        const command = new CreateAgentStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.createContactFlow = function (args, optionsOrCb, cb) {
-        var command = new CreateContactFlowCommand(args);
+    }
+    createContactFlow(args, optionsOrCb, cb) {
+        const command = new CreateContactFlowCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.createContactFlowModule = function (args, optionsOrCb, cb) {
-        var command = new CreateContactFlowModuleCommand(args);
+    }
+    createContactFlowModule(args, optionsOrCb, cb) {
+        const command = new CreateContactFlowModuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.createHoursOfOperation = function (args, optionsOrCb, cb) {
-        var command = new CreateHoursOfOperationCommand(args);
+    }
+    createHoursOfOperation(args, optionsOrCb, cb) {
+        const command = new CreateHoursOfOperationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.createInstance = function (args, optionsOrCb, cb) {
-        var command = new CreateInstanceCommand(args);
+    }
+    createInstance(args, optionsOrCb, cb) {
+        const command = new CreateInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.createIntegrationAssociation = function (args, optionsOrCb, cb) {
-        var command = new CreateIntegrationAssociationCommand(args);
+    }
+    createIntegrationAssociation(args, optionsOrCb, cb) {
+        const command = new CreateIntegrationAssociationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.createQueue = function (args, optionsOrCb, cb) {
-        var command = new CreateQueueCommand(args);
+    }
+    createQueue(args, optionsOrCb, cb) {
+        const command = new CreateQueueCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.createQuickConnect = function (args, optionsOrCb, cb) {
-        var command = new CreateQuickConnectCommand(args);
+    }
+    createQuickConnect(args, optionsOrCb, cb) {
+        const command = new CreateQuickConnectCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.createRoutingProfile = function (args, optionsOrCb, cb) {
-        var command = new CreateRoutingProfileCommand(args);
+    }
+    createRoutingProfile(args, optionsOrCb, cb) {
+        const command = new CreateRoutingProfileCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.createSecurityProfile = function (args, optionsOrCb, cb) {
-        var command = new CreateSecurityProfileCommand(args);
+    }
+    createSecurityProfile(args, optionsOrCb, cb) {
+        const command = new CreateSecurityProfileCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.createTaskTemplate = function (args, optionsOrCb, cb) {
-        var command = new CreateTaskTemplateCommand(args);
+    }
+    createTaskTemplate(args, optionsOrCb, cb) {
+        const command = new CreateTaskTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.createUseCase = function (args, optionsOrCb, cb) {
-        var command = new CreateUseCaseCommand(args);
+    }
+    createUseCase(args, optionsOrCb, cb) {
+        const command = new CreateUseCaseCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.createUser = function (args, optionsOrCb, cb) {
-        var command = new CreateUserCommand(args);
+    }
+    createUser(args, optionsOrCb, cb) {
+        const command = new CreateUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.createUserHierarchyGroup = function (args, optionsOrCb, cb) {
-        var command = new CreateUserHierarchyGroupCommand(args);
+    }
+    createUserHierarchyGroup(args, optionsOrCb, cb) {
+        const command = new CreateUserHierarchyGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.createVocabulary = function (args, optionsOrCb, cb) {
-        var command = new CreateVocabularyCommand(args);
+    }
+    createVocabulary(args, optionsOrCb, cb) {
+        const command = new CreateVocabularyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.deleteContactFlow = function (args, optionsOrCb, cb) {
-        var command = new DeleteContactFlowCommand(args);
+    }
+    deleteContactFlow(args, optionsOrCb, cb) {
+        const command = new DeleteContactFlowCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.deleteContactFlowModule = function (args, optionsOrCb, cb) {
-        var command = new DeleteContactFlowModuleCommand(args);
+    }
+    deleteContactFlowModule(args, optionsOrCb, cb) {
+        const command = new DeleteContactFlowModuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.deleteHoursOfOperation = function (args, optionsOrCb, cb) {
-        var command = new DeleteHoursOfOperationCommand(args);
+    }
+    deleteHoursOfOperation(args, optionsOrCb, cb) {
+        const command = new DeleteHoursOfOperationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.deleteInstance = function (args, optionsOrCb, cb) {
-        var command = new DeleteInstanceCommand(args);
+    }
+    deleteInstance(args, optionsOrCb, cb) {
+        const command = new DeleteInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.deleteIntegrationAssociation = function (args, optionsOrCb, cb) {
-        var command = new DeleteIntegrationAssociationCommand(args);
+    }
+    deleteIntegrationAssociation(args, optionsOrCb, cb) {
+        const command = new DeleteIntegrationAssociationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.deleteQuickConnect = function (args, optionsOrCb, cb) {
-        var command = new DeleteQuickConnectCommand(args);
+    }
+    deleteQuickConnect(args, optionsOrCb, cb) {
+        const command = new DeleteQuickConnectCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.deleteSecurityProfile = function (args, optionsOrCb, cb) {
-        var command = new DeleteSecurityProfileCommand(args);
+    }
+    deleteSecurityProfile(args, optionsOrCb, cb) {
+        const command = new DeleteSecurityProfileCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.deleteTaskTemplate = function (args, optionsOrCb, cb) {
-        var command = new DeleteTaskTemplateCommand(args);
+    }
+    deleteTaskTemplate(args, optionsOrCb, cb) {
+        const command = new DeleteTaskTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.deleteUseCase = function (args, optionsOrCb, cb) {
-        var command = new DeleteUseCaseCommand(args);
+    }
+    deleteUseCase(args, optionsOrCb, cb) {
+        const command = new DeleteUseCaseCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.deleteUser = function (args, optionsOrCb, cb) {
-        var command = new DeleteUserCommand(args);
+    }
+    deleteUser(args, optionsOrCb, cb) {
+        const command = new DeleteUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.deleteUserHierarchyGroup = function (args, optionsOrCb, cb) {
-        var command = new DeleteUserHierarchyGroupCommand(args);
+    }
+    deleteUserHierarchyGroup(args, optionsOrCb, cb) {
+        const command = new DeleteUserHierarchyGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.deleteVocabulary = function (args, optionsOrCb, cb) {
-        var command = new DeleteVocabularyCommand(args);
+    }
+    deleteVocabulary(args, optionsOrCb, cb) {
+        const command = new DeleteVocabularyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.describeAgentStatus = function (args, optionsOrCb, cb) {
-        var command = new DescribeAgentStatusCommand(args);
+    }
+    describeAgentStatus(args, optionsOrCb, cb) {
+        const command = new DescribeAgentStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.describeContact = function (args, optionsOrCb, cb) {
-        var command = new DescribeContactCommand(args);
+    }
+    describeContact(args, optionsOrCb, cb) {
+        const command = new DescribeContactCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.describeContactFlow = function (args, optionsOrCb, cb) {
-        var command = new DescribeContactFlowCommand(args);
+    }
+    describeContactFlow(args, optionsOrCb, cb) {
+        const command = new DescribeContactFlowCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.describeContactFlowModule = function (args, optionsOrCb, cb) {
-        var command = new DescribeContactFlowModuleCommand(args);
+    }
+    describeContactFlowModule(args, optionsOrCb, cb) {
+        const command = new DescribeContactFlowModuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.describeHoursOfOperation = function (args, optionsOrCb, cb) {
-        var command = new DescribeHoursOfOperationCommand(args);
+    }
+    describeHoursOfOperation(args, optionsOrCb, cb) {
+        const command = new DescribeHoursOfOperationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.describeInstance = function (args, optionsOrCb, cb) {
-        var command = new DescribeInstanceCommand(args);
+    }
+    describeInstance(args, optionsOrCb, cb) {
+        const command = new DescribeInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.describeInstanceAttribute = function (args, optionsOrCb, cb) {
-        var command = new DescribeInstanceAttributeCommand(args);
+    }
+    describeInstanceAttribute(args, optionsOrCb, cb) {
+        const command = new DescribeInstanceAttributeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.describeInstanceStorageConfig = function (args, optionsOrCb, cb) {
-        var command = new DescribeInstanceStorageConfigCommand(args);
+    }
+    describeInstanceStorageConfig(args, optionsOrCb, cb) {
+        const command = new DescribeInstanceStorageConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.describePhoneNumber = function (args, optionsOrCb, cb) {
-        var command = new DescribePhoneNumberCommand(args);
+    }
+    describePhoneNumber(args, optionsOrCb, cb) {
+        const command = new DescribePhoneNumberCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.describeQueue = function (args, optionsOrCb, cb) {
-        var command = new DescribeQueueCommand(args);
+    }
+    describeQueue(args, optionsOrCb, cb) {
+        const command = new DescribeQueueCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.describeQuickConnect = function (args, optionsOrCb, cb) {
-        var command = new DescribeQuickConnectCommand(args);
+    }
+    describeQuickConnect(args, optionsOrCb, cb) {
+        const command = new DescribeQuickConnectCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.describeRoutingProfile = function (args, optionsOrCb, cb) {
-        var command = new DescribeRoutingProfileCommand(args);
+    }
+    describeRoutingProfile(args, optionsOrCb, cb) {
+        const command = new DescribeRoutingProfileCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.describeSecurityProfile = function (args, optionsOrCb, cb) {
-        var command = new DescribeSecurityProfileCommand(args);
+    }
+    describeSecurityProfile(args, optionsOrCb, cb) {
+        const command = new DescribeSecurityProfileCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.describeUser = function (args, optionsOrCb, cb) {
-        var command = new DescribeUserCommand(args);
+    }
+    describeUser(args, optionsOrCb, cb) {
+        const command = new DescribeUserCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.describeUserHierarchyGroup = function (args, optionsOrCb, cb) {
-        var command = new DescribeUserHierarchyGroupCommand(args);
+    }
+    describeUserHierarchyGroup(args, optionsOrCb, cb) {
+        const command = new DescribeUserHierarchyGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.describeUserHierarchyStructure = function (args, optionsOrCb, cb) {
-        var command = new DescribeUserHierarchyStructureCommand(args);
+    }
+    describeUserHierarchyStructure(args, optionsOrCb, cb) {
+        const command = new DescribeUserHierarchyStructureCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.describeVocabulary = function (args, optionsOrCb, cb) {
-        var command = new DescribeVocabularyCommand(args);
+    }
+    describeVocabulary(args, optionsOrCb, cb) {
+        const command = new DescribeVocabularyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.disassociateApprovedOrigin = function (args, optionsOrCb, cb) {
-        var command = new DisassociateApprovedOriginCommand(args);
+    }
+    disassociateApprovedOrigin(args, optionsOrCb, cb) {
+        const command = new DisassociateApprovedOriginCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.disassociateBot = function (args, optionsOrCb, cb) {
-        var command = new DisassociateBotCommand(args);
+    }
+    disassociateBot(args, optionsOrCb, cb) {
+        const command = new DisassociateBotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.disassociateInstanceStorageConfig = function (args, optionsOrCb, cb) {
-        var command = new DisassociateInstanceStorageConfigCommand(args);
+    }
+    disassociateInstanceStorageConfig(args, optionsOrCb, cb) {
+        const command = new DisassociateInstanceStorageConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.disassociateLambdaFunction = function (args, optionsOrCb, cb) {
-        var command = new DisassociateLambdaFunctionCommand(args);
+    }
+    disassociateLambdaFunction(args, optionsOrCb, cb) {
+        const command = new DisassociateLambdaFunctionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.disassociateLexBot = function (args, optionsOrCb, cb) {
-        var command = new DisassociateLexBotCommand(args);
+    }
+    disassociateLexBot(args, optionsOrCb, cb) {
+        const command = new DisassociateLexBotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.disassociatePhoneNumberContactFlow = function (args, optionsOrCb, cb) {
-        var command = new DisassociatePhoneNumberContactFlowCommand(args);
+    }
+    disassociatePhoneNumberContactFlow(args, optionsOrCb, cb) {
+        const command = new DisassociatePhoneNumberContactFlowCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.disassociateQueueQuickConnects = function (args, optionsOrCb, cb) {
-        var command = new DisassociateQueueQuickConnectsCommand(args);
+    }
+    disassociateQueueQuickConnects(args, optionsOrCb, cb) {
+        const command = new DisassociateQueueQuickConnectsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.disassociateRoutingProfileQueues = function (args, optionsOrCb, cb) {
-        var command = new DisassociateRoutingProfileQueuesCommand(args);
+    }
+    disassociateRoutingProfileQueues(args, optionsOrCb, cb) {
+        const command = new DisassociateRoutingProfileQueuesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.disassociateSecurityKey = function (args, optionsOrCb, cb) {
-        var command = new DisassociateSecurityKeyCommand(args);
+    }
+    disassociateSecurityKey(args, optionsOrCb, cb) {
+        const command = new DisassociateSecurityKeyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.getContactAttributes = function (args, optionsOrCb, cb) {
-        var command = new GetContactAttributesCommand(args);
+    }
+    getContactAttributes(args, optionsOrCb, cb) {
+        const command = new GetContactAttributesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.getCurrentMetricData = function (args, optionsOrCb, cb) {
-        var command = new GetCurrentMetricDataCommand(args);
+    }
+    getCurrentMetricData(args, optionsOrCb, cb) {
+        const command = new GetCurrentMetricDataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.getCurrentUserData = function (args, optionsOrCb, cb) {
-        var command = new GetCurrentUserDataCommand(args);
+    }
+    getCurrentUserData(args, optionsOrCb, cb) {
+        const command = new GetCurrentUserDataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.getFederationToken = function (args, optionsOrCb, cb) {
-        var command = new GetFederationTokenCommand(args);
+    }
+    getFederationToken(args, optionsOrCb, cb) {
+        const command = new GetFederationTokenCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.getMetricData = function (args, optionsOrCb, cb) {
-        var command = new GetMetricDataCommand(args);
+    }
+    getMetricData(args, optionsOrCb, cb) {
+        const command = new GetMetricDataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.getTaskTemplate = function (args, optionsOrCb, cb) {
-        var command = new GetTaskTemplateCommand(args);
+    }
+    getTaskTemplate(args, optionsOrCb, cb) {
+        const command = new GetTaskTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listAgentStatuses = function (args, optionsOrCb, cb) {
-        var command = new ListAgentStatusesCommand(args);
+    }
+    listAgentStatuses(args, optionsOrCb, cb) {
+        const command = new ListAgentStatusesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listApprovedOrigins = function (args, optionsOrCb, cb) {
-        var command = new ListApprovedOriginsCommand(args);
+    }
+    listApprovedOrigins(args, optionsOrCb, cb) {
+        const command = new ListApprovedOriginsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listBots = function (args, optionsOrCb, cb) {
-        var command = new ListBotsCommand(args);
+    }
+    listBots(args, optionsOrCb, cb) {
+        const command = new ListBotsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listContactFlowModules = function (args, optionsOrCb, cb) {
-        var command = new ListContactFlowModulesCommand(args);
+    }
+    listContactFlowModules(args, optionsOrCb, cb) {
+        const command = new ListContactFlowModulesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listContactFlows = function (args, optionsOrCb, cb) {
-        var command = new ListContactFlowsCommand(args);
+    }
+    listContactFlows(args, optionsOrCb, cb) {
+        const command = new ListContactFlowsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listContactReferences = function (args, optionsOrCb, cb) {
-        var command = new ListContactReferencesCommand(args);
+    }
+    listContactReferences(args, optionsOrCb, cb) {
+        const command = new ListContactReferencesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listDefaultVocabularies = function (args, optionsOrCb, cb) {
-        var command = new ListDefaultVocabulariesCommand(args);
+    }
+    listDefaultVocabularies(args, optionsOrCb, cb) {
+        const command = new ListDefaultVocabulariesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listHoursOfOperations = function (args, optionsOrCb, cb) {
-        var command = new ListHoursOfOperationsCommand(args);
+    }
+    listHoursOfOperations(args, optionsOrCb, cb) {
+        const command = new ListHoursOfOperationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listInstanceAttributes = function (args, optionsOrCb, cb) {
-        var command = new ListInstanceAttributesCommand(args);
+    }
+    listInstanceAttributes(args, optionsOrCb, cb) {
+        const command = new ListInstanceAttributesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listInstances = function (args, optionsOrCb, cb) {
-        var command = new ListInstancesCommand(args);
+    }
+    listInstances(args, optionsOrCb, cb) {
+        const command = new ListInstancesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listInstanceStorageConfigs = function (args, optionsOrCb, cb) {
-        var command = new ListInstanceStorageConfigsCommand(args);
+    }
+    listInstanceStorageConfigs(args, optionsOrCb, cb) {
+        const command = new ListInstanceStorageConfigsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listIntegrationAssociations = function (args, optionsOrCb, cb) {
-        var command = new ListIntegrationAssociationsCommand(args);
+    }
+    listIntegrationAssociations(args, optionsOrCb, cb) {
+        const command = new ListIntegrationAssociationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listLambdaFunctions = function (args, optionsOrCb, cb) {
-        var command = new ListLambdaFunctionsCommand(args);
+    }
+    listLambdaFunctions(args, optionsOrCb, cb) {
+        const command = new ListLambdaFunctionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listLexBots = function (args, optionsOrCb, cb) {
-        var command = new ListLexBotsCommand(args);
+    }
+    listLexBots(args, optionsOrCb, cb) {
+        const command = new ListLexBotsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listPhoneNumbers = function (args, optionsOrCb, cb) {
-        var command = new ListPhoneNumbersCommand(args);
+    }
+    listPhoneNumbers(args, optionsOrCb, cb) {
+        const command = new ListPhoneNumbersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listPhoneNumbersV2 = function (args, optionsOrCb, cb) {
-        var command = new ListPhoneNumbersV2Command(args);
+    }
+    listPhoneNumbersV2(args, optionsOrCb, cb) {
+        const command = new ListPhoneNumbersV2Command(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listPrompts = function (args, optionsOrCb, cb) {
-        var command = new ListPromptsCommand(args);
+    }
+    listPrompts(args, optionsOrCb, cb) {
+        const command = new ListPromptsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listQueueQuickConnects = function (args, optionsOrCb, cb) {
-        var command = new ListQueueQuickConnectsCommand(args);
+    }
+    listQueueQuickConnects(args, optionsOrCb, cb) {
+        const command = new ListQueueQuickConnectsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listQueues = function (args, optionsOrCb, cb) {
-        var command = new ListQueuesCommand(args);
+    }
+    listQueues(args, optionsOrCb, cb) {
+        const command = new ListQueuesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listQuickConnects = function (args, optionsOrCb, cb) {
-        var command = new ListQuickConnectsCommand(args);
+    }
+    listQuickConnects(args, optionsOrCb, cb) {
+        const command = new ListQuickConnectsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listRoutingProfileQueues = function (args, optionsOrCb, cb) {
-        var command = new ListRoutingProfileQueuesCommand(args);
+    }
+    listRoutingProfileQueues(args, optionsOrCb, cb) {
+        const command = new ListRoutingProfileQueuesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listRoutingProfiles = function (args, optionsOrCb, cb) {
-        var command = new ListRoutingProfilesCommand(args);
+    }
+    listRoutingProfiles(args, optionsOrCb, cb) {
+        const command = new ListRoutingProfilesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listSecurityKeys = function (args, optionsOrCb, cb) {
-        var command = new ListSecurityKeysCommand(args);
+    }
+    listSecurityKeys(args, optionsOrCb, cb) {
+        const command = new ListSecurityKeysCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listSecurityProfilePermissions = function (args, optionsOrCb, cb) {
-        var command = new ListSecurityProfilePermissionsCommand(args);
+    }
+    listSecurityProfilePermissions(args, optionsOrCb, cb) {
+        const command = new ListSecurityProfilePermissionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listSecurityProfiles = function (args, optionsOrCb, cb) {
-        var command = new ListSecurityProfilesCommand(args);
+    }
+    listSecurityProfiles(args, optionsOrCb, cb) {
+        const command = new ListSecurityProfilesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listTagsForResource = function (args, optionsOrCb, cb) {
-        var command = new ListTagsForResourceCommand(args);
+    }
+    listTagsForResource(args, optionsOrCb, cb) {
+        const command = new ListTagsForResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listTaskTemplates = function (args, optionsOrCb, cb) {
-        var command = new ListTaskTemplatesCommand(args);
+    }
+    listTaskTemplates(args, optionsOrCb, cb) {
+        const command = new ListTaskTemplatesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listUseCases = function (args, optionsOrCb, cb) {
-        var command = new ListUseCasesCommand(args);
+    }
+    listUseCases(args, optionsOrCb, cb) {
+        const command = new ListUseCasesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listUserHierarchyGroups = function (args, optionsOrCb, cb) {
-        var command = new ListUserHierarchyGroupsCommand(args);
+    }
+    listUserHierarchyGroups(args, optionsOrCb, cb) {
+        const command = new ListUserHierarchyGroupsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.listUsers = function (args, optionsOrCb, cb) {
-        var command = new ListUsersCommand(args);
+    }
+    listUsers(args, optionsOrCb, cb) {
+        const command = new ListUsersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.putUserStatus = function (args, optionsOrCb, cb) {
-        var command = new PutUserStatusCommand(args);
+    }
+    putUserStatus(args, optionsOrCb, cb) {
+        const command = new PutUserStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.releasePhoneNumber = function (args, optionsOrCb, cb) {
-        var command = new ReleasePhoneNumberCommand(args);
+    }
+    releasePhoneNumber(args, optionsOrCb, cb) {
+        const command = new ReleasePhoneNumberCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.resumeContactRecording = function (args, optionsOrCb, cb) {
-        var command = new ResumeContactRecordingCommand(args);
+    }
+    resumeContactRecording(args, optionsOrCb, cb) {
+        const command = new ResumeContactRecordingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.searchAvailablePhoneNumbers = function (args, optionsOrCb, cb) {
-        var command = new SearchAvailablePhoneNumbersCommand(args);
+    }
+    searchAvailablePhoneNumbers(args, optionsOrCb, cb) {
+        const command = new SearchAvailablePhoneNumbersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.searchQueues = function (args, optionsOrCb, cb) {
-        var command = new SearchQueuesCommand(args);
+    }
+    searchQueues(args, optionsOrCb, cb) {
+        const command = new SearchQueuesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.searchRoutingProfiles = function (args, optionsOrCb, cb) {
-        var command = new SearchRoutingProfilesCommand(args);
+    }
+    searchRoutingProfiles(args, optionsOrCb, cb) {
+        const command = new SearchRoutingProfilesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.searchSecurityProfiles = function (args, optionsOrCb, cb) {
-        var command = new SearchSecurityProfilesCommand(args);
+    }
+    searchSecurityProfiles(args, optionsOrCb, cb) {
+        const command = new SearchSecurityProfilesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.searchUsers = function (args, optionsOrCb, cb) {
-        var command = new SearchUsersCommand(args);
+    }
+    searchUsers(args, optionsOrCb, cb) {
+        const command = new SearchUsersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.searchVocabularies = function (args, optionsOrCb, cb) {
-        var command = new SearchVocabulariesCommand(args);
+    }
+    searchVocabularies(args, optionsOrCb, cb) {
+        const command = new SearchVocabulariesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.startChatContact = function (args, optionsOrCb, cb) {
-        var command = new StartChatContactCommand(args);
+    }
+    startChatContact(args, optionsOrCb, cb) {
+        const command = new StartChatContactCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.startContactRecording = function (args, optionsOrCb, cb) {
-        var command = new StartContactRecordingCommand(args);
+    }
+    startContactRecording(args, optionsOrCb, cb) {
+        const command = new StartContactRecordingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.startContactStreaming = function (args, optionsOrCb, cb) {
-        var command = new StartContactStreamingCommand(args);
+    }
+    startContactStreaming(args, optionsOrCb, cb) {
+        const command = new StartContactStreamingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.startOutboundVoiceContact = function (args, optionsOrCb, cb) {
-        var command = new StartOutboundVoiceContactCommand(args);
+    }
+    startOutboundVoiceContact(args, optionsOrCb, cb) {
+        const command = new StartOutboundVoiceContactCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.startTaskContact = function (args, optionsOrCb, cb) {
-        var command = new StartTaskContactCommand(args);
+    }
+    startTaskContact(args, optionsOrCb, cb) {
+        const command = new StartTaskContactCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.stopContact = function (args, optionsOrCb, cb) {
-        var command = new StopContactCommand(args);
+    }
+    stopContact(args, optionsOrCb, cb) {
+        const command = new StopContactCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.stopContactRecording = function (args, optionsOrCb, cb) {
-        var command = new StopContactRecordingCommand(args);
+    }
+    stopContactRecording(args, optionsOrCb, cb) {
+        const command = new StopContactRecordingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.stopContactStreaming = function (args, optionsOrCb, cb) {
-        var command = new StopContactStreamingCommand(args);
+    }
+    stopContactStreaming(args, optionsOrCb, cb) {
+        const command = new StopContactStreamingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.suspendContactRecording = function (args, optionsOrCb, cb) {
-        var command = new SuspendContactRecordingCommand(args);
+    }
+    suspendContactRecording(args, optionsOrCb, cb) {
+        const command = new SuspendContactRecordingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.tagResource = function (args, optionsOrCb, cb) {
-        var command = new TagResourceCommand(args);
+    }
+    tagResource(args, optionsOrCb, cb) {
+        const command = new TagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.transferContact = function (args, optionsOrCb, cb) {
-        var command = new TransferContactCommand(args);
+    }
+    transferContact(args, optionsOrCb, cb) {
+        const command = new TransferContactCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.untagResource = function (args, optionsOrCb, cb) {
-        var command = new UntagResourceCommand(args);
+    }
+    untagResource(args, optionsOrCb, cb) {
+        const command = new UntagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateAgentStatus = function (args, optionsOrCb, cb) {
-        var command = new UpdateAgentStatusCommand(args);
+    }
+    updateAgentStatus(args, optionsOrCb, cb) {
+        const command = new UpdateAgentStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateContact = function (args, optionsOrCb, cb) {
-        var command = new UpdateContactCommand(args);
+    }
+    updateContact(args, optionsOrCb, cb) {
+        const command = new UpdateContactCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateContactAttributes = function (args, optionsOrCb, cb) {
-        var command = new UpdateContactAttributesCommand(args);
+    }
+    updateContactAttributes(args, optionsOrCb, cb) {
+        const command = new UpdateContactAttributesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateContactFlowContent = function (args, optionsOrCb, cb) {
-        var command = new UpdateContactFlowContentCommand(args);
+    }
+    updateContactFlowContent(args, optionsOrCb, cb) {
+        const command = new UpdateContactFlowContentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateContactFlowMetadata = function (args, optionsOrCb, cb) {
-        var command = new UpdateContactFlowMetadataCommand(args);
+    }
+    updateContactFlowMetadata(args, optionsOrCb, cb) {
+        const command = new UpdateContactFlowMetadataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateContactFlowModuleContent = function (args, optionsOrCb, cb) {
-        var command = new UpdateContactFlowModuleContentCommand(args);
+    }
+    updateContactFlowModuleContent(args, optionsOrCb, cb) {
+        const command = new UpdateContactFlowModuleContentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateContactFlowModuleMetadata = function (args, optionsOrCb, cb) {
-        var command = new UpdateContactFlowModuleMetadataCommand(args);
+    }
+    updateContactFlowModuleMetadata(args, optionsOrCb, cb) {
+        const command = new UpdateContactFlowModuleMetadataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateContactFlowName = function (args, optionsOrCb, cb) {
-        var command = new UpdateContactFlowNameCommand(args);
+    }
+    updateContactFlowName(args, optionsOrCb, cb) {
+        const command = new UpdateContactFlowNameCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateContactSchedule = function (args, optionsOrCb, cb) {
-        var command = new UpdateContactScheduleCommand(args);
+    }
+    updateContactSchedule(args, optionsOrCb, cb) {
+        const command = new UpdateContactScheduleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateHoursOfOperation = function (args, optionsOrCb, cb) {
-        var command = new UpdateHoursOfOperationCommand(args);
+    }
+    updateHoursOfOperation(args, optionsOrCb, cb) {
+        const command = new UpdateHoursOfOperationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateInstanceAttribute = function (args, optionsOrCb, cb) {
-        var command = new UpdateInstanceAttributeCommand(args);
+    }
+    updateInstanceAttribute(args, optionsOrCb, cb) {
+        const command = new UpdateInstanceAttributeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateInstanceStorageConfig = function (args, optionsOrCb, cb) {
-        var command = new UpdateInstanceStorageConfigCommand(args);
+    }
+    updateInstanceStorageConfig(args, optionsOrCb, cb) {
+        const command = new UpdateInstanceStorageConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updatePhoneNumber = function (args, optionsOrCb, cb) {
-        var command = new UpdatePhoneNumberCommand(args);
+    }
+    updatePhoneNumber(args, optionsOrCb, cb) {
+        const command = new UpdatePhoneNumberCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateQueueHoursOfOperation = function (args, optionsOrCb, cb) {
-        var command = new UpdateQueueHoursOfOperationCommand(args);
+    }
+    updateQueueHoursOfOperation(args, optionsOrCb, cb) {
+        const command = new UpdateQueueHoursOfOperationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateQueueMaxContacts = function (args, optionsOrCb, cb) {
-        var command = new UpdateQueueMaxContactsCommand(args);
+    }
+    updateQueueMaxContacts(args, optionsOrCb, cb) {
+        const command = new UpdateQueueMaxContactsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateQueueName = function (args, optionsOrCb, cb) {
-        var command = new UpdateQueueNameCommand(args);
+    }
+    updateQueueName(args, optionsOrCb, cb) {
+        const command = new UpdateQueueNameCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateQueueOutboundCallerConfig = function (args, optionsOrCb, cb) {
-        var command = new UpdateQueueOutboundCallerConfigCommand(args);
+    }
+    updateQueueOutboundCallerConfig(args, optionsOrCb, cb) {
+        const command = new UpdateQueueOutboundCallerConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateQueueStatus = function (args, optionsOrCb, cb) {
-        var command = new UpdateQueueStatusCommand(args);
+    }
+    updateQueueStatus(args, optionsOrCb, cb) {
+        const command = new UpdateQueueStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateQuickConnectConfig = function (args, optionsOrCb, cb) {
-        var command = new UpdateQuickConnectConfigCommand(args);
+    }
+    updateQuickConnectConfig(args, optionsOrCb, cb) {
+        const command = new UpdateQuickConnectConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateQuickConnectName = function (args, optionsOrCb, cb) {
-        var command = new UpdateQuickConnectNameCommand(args);
+    }
+    updateQuickConnectName(args, optionsOrCb, cb) {
+        const command = new UpdateQuickConnectNameCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateRoutingProfileConcurrency = function (args, optionsOrCb, cb) {
-        var command = new UpdateRoutingProfileConcurrencyCommand(args);
+    }
+    updateRoutingProfileConcurrency(args, optionsOrCb, cb) {
+        const command = new UpdateRoutingProfileConcurrencyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateRoutingProfileDefaultOutboundQueue = function (args, optionsOrCb, cb) {
-        var command = new UpdateRoutingProfileDefaultOutboundQueueCommand(args);
+    }
+    updateRoutingProfileDefaultOutboundQueue(args, optionsOrCb, cb) {
+        const command = new UpdateRoutingProfileDefaultOutboundQueueCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateRoutingProfileName = function (args, optionsOrCb, cb) {
-        var command = new UpdateRoutingProfileNameCommand(args);
+    }
+    updateRoutingProfileName(args, optionsOrCb, cb) {
+        const command = new UpdateRoutingProfileNameCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateRoutingProfileQueues = function (args, optionsOrCb, cb) {
-        var command = new UpdateRoutingProfileQueuesCommand(args);
+    }
+    updateRoutingProfileQueues(args, optionsOrCb, cb) {
+        const command = new UpdateRoutingProfileQueuesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateSecurityProfile = function (args, optionsOrCb, cb) {
-        var command = new UpdateSecurityProfileCommand(args);
+    }
+    updateSecurityProfile(args, optionsOrCb, cb) {
+        const command = new UpdateSecurityProfileCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateTaskTemplate = function (args, optionsOrCb, cb) {
-        var command = new UpdateTaskTemplateCommand(args);
+    }
+    updateTaskTemplate(args, optionsOrCb, cb) {
+        const command = new UpdateTaskTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateUserHierarchy = function (args, optionsOrCb, cb) {
-        var command = new UpdateUserHierarchyCommand(args);
+    }
+    updateUserHierarchy(args, optionsOrCb, cb) {
+        const command = new UpdateUserHierarchyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateUserHierarchyGroupName = function (args, optionsOrCb, cb) {
-        var command = new UpdateUserHierarchyGroupNameCommand(args);
+    }
+    updateUserHierarchyGroupName(args, optionsOrCb, cb) {
+        const command = new UpdateUserHierarchyGroupNameCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateUserHierarchyStructure = function (args, optionsOrCb, cb) {
-        var command = new UpdateUserHierarchyStructureCommand(args);
+    }
+    updateUserHierarchyStructure(args, optionsOrCb, cb) {
+        const command = new UpdateUserHierarchyStructureCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateUserIdentityInfo = function (args, optionsOrCb, cb) {
-        var command = new UpdateUserIdentityInfoCommand(args);
+    }
+    updateUserIdentityInfo(args, optionsOrCb, cb) {
+        const command = new UpdateUserIdentityInfoCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateUserPhoneConfig = function (args, optionsOrCb, cb) {
-        var command = new UpdateUserPhoneConfigCommand(args);
+    }
+    updateUserPhoneConfig(args, optionsOrCb, cb) {
+        const command = new UpdateUserPhoneConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateUserRoutingProfile = function (args, optionsOrCb, cb) {
-        var command = new UpdateUserRoutingProfileCommand(args);
+    }
+    updateUserRoutingProfile(args, optionsOrCb, cb) {
+        const command = new UpdateUserRoutingProfileCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Connect.prototype.updateUserSecurityProfiles = function (args, optionsOrCb, cb) {
-        var command = new UpdateUserSecurityProfilesCommand(args);
+    }
+    updateUserSecurityProfiles(args, optionsOrCb, cb) {
+        const command = new UpdateUserSecurityProfilesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    return Connect;
-}(ConnectClient));
-export { Connect };
+    }
+}