@aws-sdk/client-connect 3.183.0 → 3.185.0

package/dist-es/commands/ListUsersCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListUsersRequestFilterSensitiveLog, ListUsersResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1ListUsersCommand, serializeAws_restJson1ListUsersCommand, } from "../protocols/Aws_restJson1";
-export class ListUsersCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListUsersCommand = (function (_super) {
+    __extends(ListUsersCommand, _super);
+    function ListUsersCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListUsersCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ConnectClient";
-        const commandName = "ListUsersCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "ListUsersCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListUsersRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListUsersResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListUsersCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListUsersCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListUsersCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListUsersCommand(output, context);
-    }
-}
+    };
+    return ListUsersCommand;
+}($Command));
+export { ListUsersCommand };

package/dist-es/commands/PutUserStatusCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { PutUserStatusRequestFilterSensitiveLog, PutUserStatusResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1PutUserStatusCommand, serializeAws_restJson1PutUserStatusCommand, } from "../protocols/Aws_restJson1";
-export class PutUserStatusCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var PutUserStatusCommand = (function (_super) {
+    __extends(PutUserStatusCommand, _super);
+    function PutUserStatusCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    PutUserStatusCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ConnectClient";
-        const commandName = "PutUserStatusCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "PutUserStatusCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: PutUserStatusRequestFilterSensitiveLog,
             outputFilterSensitiveLog: PutUserStatusResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    PutUserStatusCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1PutUserStatusCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    PutUserStatusCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1PutUserStatusCommand(output, context);
-    }
-}
+    };
+    return PutUserStatusCommand;
+}($Command));
+export { PutUserStatusCommand };

package/dist-es/commands/ReleasePhoneNumberCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ReleasePhoneNumberRequestFilterSensitiveLog } from "../models/models_1";
 import { deserializeAws_restJson1ReleasePhoneNumberCommand, serializeAws_restJson1ReleasePhoneNumberCommand, } from "../protocols/Aws_restJson1";
-export class ReleasePhoneNumberCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ReleasePhoneNumberCommand = (function (_super) {
+    __extends(ReleasePhoneNumberCommand, _super);
+    function ReleasePhoneNumberCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ReleasePhoneNumberCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ConnectClient";
-        const commandName = "ReleasePhoneNumberCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "ReleasePhoneNumberCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ReleasePhoneNumberRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: (output) => output,
+            outputFilterSensitiveLog: function (output) { return output; },
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ReleasePhoneNumberCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ReleasePhoneNumberCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ReleasePhoneNumberCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ReleasePhoneNumberCommand(output, context);
-    }
-}
+    };
+    return ReleasePhoneNumberCommand;
+}($Command));
+export { ReleasePhoneNumberCommand };

package/dist-es/commands/ResumeContactRecordingCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ResumeContactRecordingRequestFilterSensitiveLog, ResumeContactRecordingResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1ResumeContactRecordingCommand, serializeAws_restJson1ResumeContactRecordingCommand, } from "../protocols/Aws_restJson1";
-export class ResumeContactRecordingCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ResumeContactRecordingCommand = (function (_super) {
+    __extends(ResumeContactRecordingCommand, _super);
+    function ResumeContactRecordingCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ResumeContactRecordingCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ConnectClient";
-        const commandName = "ResumeContactRecordingCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "ResumeContactRecordingCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ResumeContactRecordingRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ResumeContactRecordingResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ResumeContactRecordingCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ResumeContactRecordingCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ResumeContactRecordingCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ResumeContactRecordingCommand(output, context);
-    }
-}
+    };
+    return ResumeContactRecordingCommand;
+}($Command));
+export { ResumeContactRecordingCommand };

package/dist-es/commands/SearchAvailablePhoneNumbersCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { SearchAvailablePhoneNumbersRequestFilterSensitiveLog, SearchAvailablePhoneNumbersResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1SearchAvailablePhoneNumbersCommand, serializeAws_restJson1SearchAvailablePhoneNumbersCommand, } from "../protocols/Aws_restJson1";
-export class SearchAvailablePhoneNumbersCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var SearchAvailablePhoneNumbersCommand = (function (_super) {
+    __extends(SearchAvailablePhoneNumbersCommand, _super);
+    function SearchAvailablePhoneNumbersCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    SearchAvailablePhoneNumbersCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ConnectClient";
-        const commandName = "SearchAvailablePhoneNumbersCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "SearchAvailablePhoneNumbersCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: SearchAvailablePhoneNumbersRequestFilterSensitiveLog,
             outputFilterSensitiveLog: SearchAvailablePhoneNumbersResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SearchAvailablePhoneNumbersCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1SearchAvailablePhoneNumbersCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    SearchAvailablePhoneNumbersCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1SearchAvailablePhoneNumbersCommand(output, context);
-    }
-}
+    };
+    return SearchAvailablePhoneNumbersCommand;
+}($Command));
+export { SearchAvailablePhoneNumbersCommand };

package/dist-es/commands/SearchQueuesCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { SearchQueuesRequestFilterSensitiveLog, SearchQueuesResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1SearchQueuesCommand, serializeAws_restJson1SearchQueuesCommand, } from "../protocols/Aws_restJson1";
-export class SearchQueuesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var SearchQueuesCommand = (function (_super) {
+    __extends(SearchQueuesCommand, _super);
+    function SearchQueuesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    SearchQueuesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ConnectClient";
-        const commandName = "SearchQueuesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "SearchQueuesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: SearchQueuesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: SearchQueuesResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SearchQueuesCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1SearchQueuesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    SearchQueuesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1SearchQueuesCommand(output, context);
-    }
-}
+    };
+    return SearchQueuesCommand;
+}($Command));
+export { SearchQueuesCommand };

package/dist-es/commands/SearchRoutingProfilesCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { SearchRoutingProfilesRequestFilterSensitiveLog, SearchRoutingProfilesResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1SearchRoutingProfilesCommand, serializeAws_restJson1SearchRoutingProfilesCommand, } from "../protocols/Aws_restJson1";
-export class SearchRoutingProfilesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var SearchRoutingProfilesCommand = (function (_super) {
+    __extends(SearchRoutingProfilesCommand, _super);
+    function SearchRoutingProfilesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    SearchRoutingProfilesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ConnectClient";
-        const commandName = "SearchRoutingProfilesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "SearchRoutingProfilesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: SearchRoutingProfilesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: SearchRoutingProfilesResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SearchRoutingProfilesCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1SearchRoutingProfilesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    SearchRoutingProfilesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1SearchRoutingProfilesCommand(output, context);
-    }
-}
+    };
+    return SearchRoutingProfilesCommand;
+}($Command));
+export { SearchRoutingProfilesCommand };

package/dist-es/commands/SearchSecurityProfilesCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { SearchSecurityProfilesRequestFilterSensitiveLog, SearchSecurityProfilesResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1SearchSecurityProfilesCommand, serializeAws_restJson1SearchSecurityProfilesCommand, } from "../protocols/Aws_restJson1";
-export class SearchSecurityProfilesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var SearchSecurityProfilesCommand = (function (_super) {
+    __extends(SearchSecurityProfilesCommand, _super);
+    function SearchSecurityProfilesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    SearchSecurityProfilesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ConnectClient";
-        const commandName = "SearchSecurityProfilesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "SearchSecurityProfilesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: SearchSecurityProfilesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: SearchSecurityProfilesResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SearchSecurityProfilesCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1SearchSecurityProfilesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    SearchSecurityProfilesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1SearchSecurityProfilesCommand(output, context);
-    }
-}
+    };
+    return SearchSecurityProfilesCommand;
+}($Command));
+export { SearchSecurityProfilesCommand };

package/dist-es/commands/SearchUsersCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { SearchUsersRequestFilterSensitiveLog, SearchUsersResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1SearchUsersCommand, serializeAws_restJson1SearchUsersCommand, } from "../protocols/Aws_restJson1";
-export class SearchUsersCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var SearchUsersCommand = (function (_super) {
+    __extends(SearchUsersCommand, _super);
+    function SearchUsersCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    SearchUsersCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ConnectClient";
-        const commandName = "SearchUsersCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "SearchUsersCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: SearchUsersRequestFilterSensitiveLog,
             outputFilterSensitiveLog: SearchUsersResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SearchUsersCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1SearchUsersCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    SearchUsersCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1SearchUsersCommand(output, context);
-    }
-}
+    };
+    return SearchUsersCommand;
+}($Command));
+export { SearchUsersCommand };

package/dist-es/commands/SearchVocabulariesCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { SearchVocabulariesRequestFilterSensitiveLog, SearchVocabulariesResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1SearchVocabulariesCommand, serializeAws_restJson1SearchVocabulariesCommand, } from "../protocols/Aws_restJson1";
-export class SearchVocabulariesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var SearchVocabulariesCommand = (function (_super) {
+    __extends(SearchVocabulariesCommand, _super);
+    function SearchVocabulariesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    SearchVocabulariesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ConnectClient";
-        const commandName = "SearchVocabulariesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "SearchVocabulariesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: SearchVocabulariesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: SearchVocabulariesResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SearchVocabulariesCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1SearchVocabulariesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    SearchVocabulariesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1SearchVocabulariesCommand(output, context);
-    }
-}
+    };
+    return SearchVocabulariesCommand;
+}($Command));
+export { SearchVocabulariesCommand };