@aws-sdk/client-connect 3.183.0 → 3.185.0

package/dist-es/Connect.js

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