@aws-sdk/client-connect 3.183.0 → 3.185.0

package/dist-es/commands/GetTaskTemplateCommand.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 { GetTaskTemplateRequestFilterSensitiveLog, GetTaskTemplateResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetTaskTemplateCommand, serializeAws_restJson1GetTaskTemplateCommand, } from "../protocols/Aws_restJson1";
-export class GetTaskTemplateCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetTaskTemplateCommand = (function (_super) {
+    __extends(GetTaskTemplateCommand, _super);
+    function GetTaskTemplateCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetTaskTemplateCommand.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 = "GetTaskTemplateCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "GetTaskTemplateCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetTaskTemplateRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetTaskTemplateResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetTaskTemplateCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetTaskTemplateCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetTaskTemplateCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetTaskTemplateCommand(output, context);
-    }
-}
+    };
+    return GetTaskTemplateCommand;
+}($Command));
+export { GetTaskTemplateCommand };

package/dist-es/commands/ListAgentStatusesCommand.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 { ListAgentStatusRequestFilterSensitiveLog, ListAgentStatusResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListAgentStatusesCommand, serializeAws_restJson1ListAgentStatusesCommand, } from "../protocols/Aws_restJson1";
-export class ListAgentStatusesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListAgentStatusesCommand = (function (_super) {
+    __extends(ListAgentStatusesCommand, _super);
+    function ListAgentStatusesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListAgentStatusesCommand.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 = "ListAgentStatusesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "ListAgentStatusesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListAgentStatusRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListAgentStatusResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ListAgentStatusesCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListAgentStatusesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListAgentStatusesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListAgentStatusesCommand(output, context);
-    }
-}
+    };
+    return ListAgentStatusesCommand;
+}($Command));
+export { ListAgentStatusesCommand };

package/dist-es/commands/ListApprovedOriginsCommand.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 { ListApprovedOriginsRequestFilterSensitiveLog, ListApprovedOriginsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListApprovedOriginsCommand, serializeAws_restJson1ListApprovedOriginsCommand, } from "../protocols/Aws_restJson1";
-export class ListApprovedOriginsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListApprovedOriginsCommand = (function (_super) {
+    __extends(ListApprovedOriginsCommand, _super);
+    function ListApprovedOriginsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListApprovedOriginsCommand.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 = "ListApprovedOriginsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "ListApprovedOriginsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListApprovedOriginsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListApprovedOriginsResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ListApprovedOriginsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListApprovedOriginsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListApprovedOriginsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListApprovedOriginsCommand(output, context);
-    }
-}
+    };
+    return ListApprovedOriginsCommand;
+}($Command));
+export { ListApprovedOriginsCommand };

package/dist-es/commands/ListBotsCommand.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 { ListBotsRequestFilterSensitiveLog, ListBotsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListBotsCommand, serializeAws_restJson1ListBotsCommand, } from "../protocols/Aws_restJson1";
-export class ListBotsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListBotsCommand = (function (_super) {
+    __extends(ListBotsCommand, _super);
+    function ListBotsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListBotsCommand.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 = "ListBotsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "ListBotsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListBotsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListBotsResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ListBotsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListBotsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListBotsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListBotsCommand(output, context);
-    }
-}
+    };
+    return ListBotsCommand;
+}($Command));
+export { ListBotsCommand };

package/dist-es/commands/ListContactFlowModulesCommand.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 { ListContactFlowModulesRequestFilterSensitiveLog, ListContactFlowModulesResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListContactFlowModulesCommand, serializeAws_restJson1ListContactFlowModulesCommand, } from "../protocols/Aws_restJson1";
-export class ListContactFlowModulesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListContactFlowModulesCommand = (function (_super) {
+    __extends(ListContactFlowModulesCommand, _super);
+    function ListContactFlowModulesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListContactFlowModulesCommand.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 = "ListContactFlowModulesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "ListContactFlowModulesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListContactFlowModulesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListContactFlowModulesResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ListContactFlowModulesCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListContactFlowModulesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListContactFlowModulesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListContactFlowModulesCommand(output, context);
-    }
-}
+    };
+    return ListContactFlowModulesCommand;
+}($Command));
+export { ListContactFlowModulesCommand };

package/dist-es/commands/ListContactFlowsCommand.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 { ListContactFlowsRequestFilterSensitiveLog, ListContactFlowsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListContactFlowsCommand, serializeAws_restJson1ListContactFlowsCommand, } from "../protocols/Aws_restJson1";
-export class ListContactFlowsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListContactFlowsCommand = (function (_super) {
+    __extends(ListContactFlowsCommand, _super);
+    function ListContactFlowsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListContactFlowsCommand.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 = "ListContactFlowsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "ListContactFlowsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListContactFlowsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListContactFlowsResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ListContactFlowsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListContactFlowsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListContactFlowsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListContactFlowsCommand(output, context);
-    }
-}
+    };
+    return ListContactFlowsCommand;
+}($Command));
+export { ListContactFlowsCommand };

package/dist-es/commands/ListContactReferencesCommand.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 { ListContactReferencesRequestFilterSensitiveLog, ListContactReferencesResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListContactReferencesCommand, serializeAws_restJson1ListContactReferencesCommand, } from "../protocols/Aws_restJson1";
-export class ListContactReferencesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListContactReferencesCommand = (function (_super) {
+    __extends(ListContactReferencesCommand, _super);
+    function ListContactReferencesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListContactReferencesCommand.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 = "ListContactReferencesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "ListContactReferencesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListContactReferencesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListContactReferencesResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ListContactReferencesCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListContactReferencesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListContactReferencesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListContactReferencesCommand(output, context);
-    }
-}
+    };
+    return ListContactReferencesCommand;
+}($Command));
+export { ListContactReferencesCommand };

package/dist-es/commands/ListDefaultVocabulariesCommand.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 { ListDefaultVocabulariesRequestFilterSensitiveLog, ListDefaultVocabulariesResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListDefaultVocabulariesCommand, serializeAws_restJson1ListDefaultVocabulariesCommand, } from "../protocols/Aws_restJson1";
-export class ListDefaultVocabulariesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListDefaultVocabulariesCommand = (function (_super) {
+    __extends(ListDefaultVocabulariesCommand, _super);
+    function ListDefaultVocabulariesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListDefaultVocabulariesCommand.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 = "ListDefaultVocabulariesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "ListDefaultVocabulariesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListDefaultVocabulariesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListDefaultVocabulariesResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ListDefaultVocabulariesCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListDefaultVocabulariesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListDefaultVocabulariesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListDefaultVocabulariesCommand(output, context);
-    }
-}
+    };
+    return ListDefaultVocabulariesCommand;
+}($Command));
+export { ListDefaultVocabulariesCommand };

package/dist-es/commands/ListHoursOfOperationsCommand.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 { ListHoursOfOperationsRequestFilterSensitiveLog, ListHoursOfOperationsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListHoursOfOperationsCommand, serializeAws_restJson1ListHoursOfOperationsCommand, } from "../protocols/Aws_restJson1";
-export class ListHoursOfOperationsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListHoursOfOperationsCommand = (function (_super) {
+    __extends(ListHoursOfOperationsCommand, _super);
+    function ListHoursOfOperationsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListHoursOfOperationsCommand.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 = "ListHoursOfOperationsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "ListHoursOfOperationsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListHoursOfOperationsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListHoursOfOperationsResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ListHoursOfOperationsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListHoursOfOperationsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListHoursOfOperationsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListHoursOfOperationsCommand(output, context);
-    }
-}
+    };
+    return ListHoursOfOperationsCommand;
+}($Command));
+export { ListHoursOfOperationsCommand };

package/dist-es/commands/ListInstanceAttributesCommand.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 { ListInstanceAttributesRequestFilterSensitiveLog, ListInstanceAttributesResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListInstanceAttributesCommand, serializeAws_restJson1ListInstanceAttributesCommand, } from "../protocols/Aws_restJson1";
-export class ListInstanceAttributesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListInstanceAttributesCommand = (function (_super) {
+    __extends(ListInstanceAttributesCommand, _super);
+    function ListInstanceAttributesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListInstanceAttributesCommand.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 = "ListInstanceAttributesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "ListInstanceAttributesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListInstanceAttributesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListInstanceAttributesResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ListInstanceAttributesCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListInstanceAttributesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListInstanceAttributesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListInstanceAttributesCommand(output, context);
-    }
-}
+    };
+    return ListInstanceAttributesCommand;
+}($Command));
+export { ListInstanceAttributesCommand };