@aws-sdk/client-connect 3.34.0 → 3.37.0

package/dist-es/commands/StopContactCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { StopContactRequest, StopContactResponse } from "../models/models_0";
+import { deserializeAws_restJson1StopContactCommand, serializeAws_restJson1StopContactCommand, } from "../protocols/Aws_restJson1";
+var StopContactCommand = (function (_super) {
+    __extends(StopContactCommand, _super);
+    function StopContactCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    StopContactCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "StopContactCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: StopContactRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: StopContactResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StopContactCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1StopContactCommand(input, context);
+    };
+    StopContactCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1StopContactCommand(output, context);
+    };
+    return StopContactCommand;
+}($Command));
+export { StopContactCommand };

package/dist-es/commands/StopContactRecordingCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { StopContactRecordingRequest, StopContactRecordingResponse } from "../models/models_0";
+import { deserializeAws_restJson1StopContactRecordingCommand, serializeAws_restJson1StopContactRecordingCommand, } from "../protocols/Aws_restJson1";
+var StopContactRecordingCommand = (function (_super) {
+    __extends(StopContactRecordingCommand, _super);
+    function StopContactRecordingCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    StopContactRecordingCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "StopContactRecordingCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: StopContactRecordingRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: StopContactRecordingResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StopContactRecordingCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1StopContactRecordingCommand(input, context);
+    };
+    StopContactRecordingCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1StopContactRecordingCommand(output, context);
+    };
+    return StopContactRecordingCommand;
+}($Command));
+export { StopContactRecordingCommand };

package/dist-es/commands/SuspendContactRecordingCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { SuspendContactRecordingRequest, SuspendContactRecordingResponse } from "../models/models_0";
+import { deserializeAws_restJson1SuspendContactRecordingCommand, serializeAws_restJson1SuspendContactRecordingCommand, } from "../protocols/Aws_restJson1";
+var SuspendContactRecordingCommand = (function (_super) {
+    __extends(SuspendContactRecordingCommand, _super);
+    function SuspendContactRecordingCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    SuspendContactRecordingCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "SuspendContactRecordingCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: SuspendContactRecordingRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: SuspendContactRecordingResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SuspendContactRecordingCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1SuspendContactRecordingCommand(input, context);
+    };
+    SuspendContactRecordingCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1SuspendContactRecordingCommand(output, context);
+    };
+    return SuspendContactRecordingCommand;
+}($Command));
+export { SuspendContactRecordingCommand };

package/dist-es/commands/TagResourceCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { TagResourceRequest } from "../models/models_0";
+import { deserializeAws_restJson1TagResourceCommand, serializeAws_restJson1TagResourceCommand, } from "../protocols/Aws_restJson1";
+var TagResourceCommand = (function (_super) {
+    __extends(TagResourceCommand, _super);
+    function TagResourceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    TagResourceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "TagResourceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: TagResourceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    TagResourceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1TagResourceCommand(input, context);
+    };
+    TagResourceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1TagResourceCommand(output, context);
+    };
+    return TagResourceCommand;
+}($Command));
+export { TagResourceCommand };

package/dist-es/commands/UntagResourceCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UntagResourceRequest } from "../models/models_0";
+import { deserializeAws_restJson1UntagResourceCommand, serializeAws_restJson1UntagResourceCommand, } from "../protocols/Aws_restJson1";
+var UntagResourceCommand = (function (_super) {
+    __extends(UntagResourceCommand, _super);
+    function UntagResourceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UntagResourceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "UntagResourceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UntagResourceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UntagResourceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1UntagResourceCommand(input, context);
+    };
+    UntagResourceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1UntagResourceCommand(output, context);
+    };
+    return UntagResourceCommand;
+}($Command));
+export { UntagResourceCommand };

package/dist-es/commands/UpdateAgentStatusCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateAgentStatusRequest } from "../models/models_0";
+import { deserializeAws_restJson1UpdateAgentStatusCommand, serializeAws_restJson1UpdateAgentStatusCommand, } from "../protocols/Aws_restJson1";
+var UpdateAgentStatusCommand = (function (_super) {
+    __extends(UpdateAgentStatusCommand, _super);
+    function UpdateAgentStatusCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateAgentStatusCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "UpdateAgentStatusCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateAgentStatusRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateAgentStatusCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1UpdateAgentStatusCommand(input, context);
+    };
+    UpdateAgentStatusCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1UpdateAgentStatusCommand(output, context);
+    };
+    return UpdateAgentStatusCommand;
+}($Command));
+export { UpdateAgentStatusCommand };

package/dist-es/commands/UpdateContactAttributesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateContactAttributesRequest, UpdateContactAttributesResponse } from "../models/models_0";
+import { deserializeAws_restJson1UpdateContactAttributesCommand, serializeAws_restJson1UpdateContactAttributesCommand, } from "../protocols/Aws_restJson1";
+var UpdateContactAttributesCommand = (function (_super) {
+    __extends(UpdateContactAttributesCommand, _super);
+    function UpdateContactAttributesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateContactAttributesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "UpdateContactAttributesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateContactAttributesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: UpdateContactAttributesResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateContactAttributesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1UpdateContactAttributesCommand(input, context);
+    };
+    UpdateContactAttributesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1UpdateContactAttributesCommand(output, context);
+    };
+    return UpdateContactAttributesCommand;
+}($Command));
+export { UpdateContactAttributesCommand };

package/dist-es/commands/UpdateContactFlowContentCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateContactFlowContentRequest } from "../models/models_0";
+import { deserializeAws_restJson1UpdateContactFlowContentCommand, serializeAws_restJson1UpdateContactFlowContentCommand, } from "../protocols/Aws_restJson1";
+var UpdateContactFlowContentCommand = (function (_super) {
+    __extends(UpdateContactFlowContentCommand, _super);
+    function UpdateContactFlowContentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateContactFlowContentCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "UpdateContactFlowContentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateContactFlowContentRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateContactFlowContentCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1UpdateContactFlowContentCommand(input, context);
+    };
+    UpdateContactFlowContentCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1UpdateContactFlowContentCommand(output, context);
+    };
+    return UpdateContactFlowContentCommand;
+}($Command));
+export { UpdateContactFlowContentCommand };

package/dist-es/commands/UpdateContactFlowNameCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateContactFlowNameRequest } from "../models/models_0";
+import { deserializeAws_restJson1UpdateContactFlowNameCommand, serializeAws_restJson1UpdateContactFlowNameCommand, } from "../protocols/Aws_restJson1";
+var UpdateContactFlowNameCommand = (function (_super) {
+    __extends(UpdateContactFlowNameCommand, _super);
+    function UpdateContactFlowNameCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateContactFlowNameCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "UpdateContactFlowNameCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateContactFlowNameRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateContactFlowNameCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1UpdateContactFlowNameCommand(input, context);
+    };
+    UpdateContactFlowNameCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1UpdateContactFlowNameCommand(output, context);
+    };
+    return UpdateContactFlowNameCommand;
+}($Command));
+export { UpdateContactFlowNameCommand };

package/dist-es/commands/UpdateHoursOfOperationCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateHoursOfOperationRequest } from "../models/models_0";
+import { deserializeAws_restJson1UpdateHoursOfOperationCommand, serializeAws_restJson1UpdateHoursOfOperationCommand, } from "../protocols/Aws_restJson1";
+var UpdateHoursOfOperationCommand = (function (_super) {
+    __extends(UpdateHoursOfOperationCommand, _super);
+    function UpdateHoursOfOperationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateHoursOfOperationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "UpdateHoursOfOperationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateHoursOfOperationRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateHoursOfOperationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1UpdateHoursOfOperationCommand(input, context);
+    };
+    UpdateHoursOfOperationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1UpdateHoursOfOperationCommand(output, context);
+    };
+    return UpdateHoursOfOperationCommand;
+}($Command));
+export { UpdateHoursOfOperationCommand };

package/dist-es/commands/UpdateInstanceAttributeCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateInstanceAttributeRequest } from "../models/models_0";
+import { deserializeAws_restJson1UpdateInstanceAttributeCommand, serializeAws_restJson1UpdateInstanceAttributeCommand, } from "../protocols/Aws_restJson1";
+var UpdateInstanceAttributeCommand = (function (_super) {
+    __extends(UpdateInstanceAttributeCommand, _super);
+    function UpdateInstanceAttributeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateInstanceAttributeCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "UpdateInstanceAttributeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateInstanceAttributeRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateInstanceAttributeCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1UpdateInstanceAttributeCommand(input, context);
+    };
+    UpdateInstanceAttributeCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1UpdateInstanceAttributeCommand(output, context);
+    };
+    return UpdateInstanceAttributeCommand;
+}($Command));
+export { UpdateInstanceAttributeCommand };

package/dist-es/commands/UpdateInstanceStorageConfigCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateInstanceStorageConfigRequest } from "../models/models_0";
+import { deserializeAws_restJson1UpdateInstanceStorageConfigCommand, serializeAws_restJson1UpdateInstanceStorageConfigCommand, } from "../protocols/Aws_restJson1";
+var UpdateInstanceStorageConfigCommand = (function (_super) {
+    __extends(UpdateInstanceStorageConfigCommand, _super);
+    function UpdateInstanceStorageConfigCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateInstanceStorageConfigCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "UpdateInstanceStorageConfigCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateInstanceStorageConfigRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateInstanceStorageConfigCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1UpdateInstanceStorageConfigCommand(input, context);
+    };
+    UpdateInstanceStorageConfigCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1UpdateInstanceStorageConfigCommand(output, context);
+    };
+    return UpdateInstanceStorageConfigCommand;
+}($Command));
+export { UpdateInstanceStorageConfigCommand };

package/dist-es/commands/UpdateQueueHoursOfOperationCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateQueueHoursOfOperationRequest } from "../models/models_0";
+import { deserializeAws_restJson1UpdateQueueHoursOfOperationCommand, serializeAws_restJson1UpdateQueueHoursOfOperationCommand, } from "../protocols/Aws_restJson1";
+var UpdateQueueHoursOfOperationCommand = (function (_super) {
+    __extends(UpdateQueueHoursOfOperationCommand, _super);
+    function UpdateQueueHoursOfOperationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateQueueHoursOfOperationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "UpdateQueueHoursOfOperationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateQueueHoursOfOperationRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateQueueHoursOfOperationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1UpdateQueueHoursOfOperationCommand(input, context);
+    };
+    UpdateQueueHoursOfOperationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1UpdateQueueHoursOfOperationCommand(output, context);
+    };
+    return UpdateQueueHoursOfOperationCommand;
+}($Command));
+export { UpdateQueueHoursOfOperationCommand };

package/dist-es/commands/UpdateQueueMaxContactsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateQueueMaxContactsRequest } from "../models/models_0";
+import { deserializeAws_restJson1UpdateQueueMaxContactsCommand, serializeAws_restJson1UpdateQueueMaxContactsCommand, } from "../protocols/Aws_restJson1";
+var UpdateQueueMaxContactsCommand = (function (_super) {
+    __extends(UpdateQueueMaxContactsCommand, _super);
+    function UpdateQueueMaxContactsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateQueueMaxContactsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "UpdateQueueMaxContactsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateQueueMaxContactsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateQueueMaxContactsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1UpdateQueueMaxContactsCommand(input, context);
+    };
+    UpdateQueueMaxContactsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1UpdateQueueMaxContactsCommand(output, context);
+    };
+    return UpdateQueueMaxContactsCommand;
+}($Command));
+export { UpdateQueueMaxContactsCommand };

package/dist-es/commands/UpdateQueueNameCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateQueueNameRequest } from "../models/models_0";
+import { deserializeAws_restJson1UpdateQueueNameCommand, serializeAws_restJson1UpdateQueueNameCommand, } from "../protocols/Aws_restJson1";
+var UpdateQueueNameCommand = (function (_super) {
+    __extends(UpdateQueueNameCommand, _super);
+    function UpdateQueueNameCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateQueueNameCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "UpdateQueueNameCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateQueueNameRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateQueueNameCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1UpdateQueueNameCommand(input, context);
+    };
+    UpdateQueueNameCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1UpdateQueueNameCommand(output, context);
+    };
+    return UpdateQueueNameCommand;
+}($Command));
+export { UpdateQueueNameCommand };

package/dist-es/commands/UpdateQueueOutboundCallerConfigCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateQueueOutboundCallerConfigRequest } from "../models/models_0";
+import { deserializeAws_restJson1UpdateQueueOutboundCallerConfigCommand, serializeAws_restJson1UpdateQueueOutboundCallerConfigCommand, } from "../protocols/Aws_restJson1";
+var UpdateQueueOutboundCallerConfigCommand = (function (_super) {
+    __extends(UpdateQueueOutboundCallerConfigCommand, _super);
+    function UpdateQueueOutboundCallerConfigCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateQueueOutboundCallerConfigCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ConnectClient";
+        var commandName = "UpdateQueueOutboundCallerConfigCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateQueueOutboundCallerConfigRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateQueueOutboundCallerConfigCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1UpdateQueueOutboundCallerConfigCommand(input, context);
+    };
+    UpdateQueueOutboundCallerConfigCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1UpdateQueueOutboundCallerConfigCommand(output, context);
+    };
+    return UpdateQueueOutboundCallerConfigCommand;
+}($Command));
+export { UpdateQueueOutboundCallerConfigCommand };