@aws-sdk/client-connect 3.184.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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