@aws-sdk/client-connect 3.34.0 → 3.37.0

package/dist-es/ConnectClient.js

@@ -0,0 +1,37 @@
+import { __extends } from "tslib";
+import { resolveEndpointsConfig, resolveRegionConfig, } from "@aws-sdk/config-resolver";
+import { getContentLengthPlugin } from "@aws-sdk/middleware-content-length";
+import { getHostHeaderPlugin, resolveHostHeaderConfig, } from "@aws-sdk/middleware-host-header";
+import { getLoggerPlugin } from "@aws-sdk/middleware-logger";
+import { getRetryPlugin, resolveRetryConfig } from "@aws-sdk/middleware-retry";
+import { getAwsAuthPlugin, resolveAwsAuthConfig, } from "@aws-sdk/middleware-signing";
+import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
+import { Client as __Client, } from "@aws-sdk/smithy-client";
+import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
+var ConnectClient = (function (_super) {
+    __extends(ConnectClient, _super);
+    function ConnectClient(configuration) {
+        var _this = this;
+        var _config_0 = __getRuntimeConfig(configuration);
+        var _config_1 = resolveRegionConfig(_config_0);
+        var _config_2 = resolveEndpointsConfig(_config_1);
+        var _config_3 = resolveRetryConfig(_config_2);
+        var _config_4 = resolveHostHeaderConfig(_config_3);
+        var _config_5 = resolveAwsAuthConfig(_config_4);
+        var _config_6 = resolveUserAgentConfig(_config_5);
+        _this = _super.call(this, _config_6) || this;
+        _this.config = _config_6;
+        _this.middlewareStack.use(getRetryPlugin(_this.config));
+        _this.middlewareStack.use(getContentLengthPlugin(_this.config));
+        _this.middlewareStack.use(getHostHeaderPlugin(_this.config));
+        _this.middlewareStack.use(getLoggerPlugin(_this.config));
+        _this.middlewareStack.use(getAwsAuthPlugin(_this.config));
+        _this.middlewareStack.use(getUserAgentPlugin(_this.config));
+        return _this;
+    }
+    ConnectClient.prototype.destroy = function () {
+        _super.prototype.destroy.call(this);
+    };
+    return ConnectClient;
+}(__Client));
+export { ConnectClient };

package/dist-es/commands/AssociateApprovedOriginCommand.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 { AssociateApprovedOriginRequest } from "../models/models_0";
+import { deserializeAws_restJson1AssociateApprovedOriginCommand, serializeAws_restJson1AssociateApprovedOriginCommand, } from "../protocols/Aws_restJson1";
+var AssociateApprovedOriginCommand = (function (_super) {
+    __extends(AssociateApprovedOriginCommand, _super);
+    function AssociateApprovedOriginCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    AssociateApprovedOriginCommand.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 = "AssociateApprovedOriginCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: AssociateApprovedOriginRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AssociateApprovedOriginCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1AssociateApprovedOriginCommand(input, context);
+    };
+    AssociateApprovedOriginCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1AssociateApprovedOriginCommand(output, context);
+    };
+    return AssociateApprovedOriginCommand;
+}($Command));
+export { AssociateApprovedOriginCommand };

package/dist-es/commands/AssociateBotCommand.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 { AssociateBotRequest } from "../models/models_0";
+import { deserializeAws_restJson1AssociateBotCommand, serializeAws_restJson1AssociateBotCommand, } from "../protocols/Aws_restJson1";
+var AssociateBotCommand = (function (_super) {
+    __extends(AssociateBotCommand, _super);
+    function AssociateBotCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    AssociateBotCommand.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 = "AssociateBotCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: AssociateBotRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AssociateBotCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1AssociateBotCommand(input, context);
+    };
+    AssociateBotCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1AssociateBotCommand(output, context);
+    };
+    return AssociateBotCommand;
+}($Command));
+export { AssociateBotCommand };

package/dist-es/commands/AssociateInstanceStorageConfigCommand.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 { AssociateInstanceStorageConfigRequest, AssociateInstanceStorageConfigResponse } from "../models/models_0";
+import { deserializeAws_restJson1AssociateInstanceStorageConfigCommand, serializeAws_restJson1AssociateInstanceStorageConfigCommand, } from "../protocols/Aws_restJson1";
+var AssociateInstanceStorageConfigCommand = (function (_super) {
+    __extends(AssociateInstanceStorageConfigCommand, _super);
+    function AssociateInstanceStorageConfigCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    AssociateInstanceStorageConfigCommand.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 = "AssociateInstanceStorageConfigCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: AssociateInstanceStorageConfigRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: AssociateInstanceStorageConfigResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AssociateInstanceStorageConfigCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1AssociateInstanceStorageConfigCommand(input, context);
+    };
+    AssociateInstanceStorageConfigCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1AssociateInstanceStorageConfigCommand(output, context);
+    };
+    return AssociateInstanceStorageConfigCommand;
+}($Command));
+export { AssociateInstanceStorageConfigCommand };

package/dist-es/commands/AssociateLambdaFunctionCommand.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 { AssociateLambdaFunctionRequest } from "../models/models_0";
+import { deserializeAws_restJson1AssociateLambdaFunctionCommand, serializeAws_restJson1AssociateLambdaFunctionCommand, } from "../protocols/Aws_restJson1";
+var AssociateLambdaFunctionCommand = (function (_super) {
+    __extends(AssociateLambdaFunctionCommand, _super);
+    function AssociateLambdaFunctionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    AssociateLambdaFunctionCommand.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 = "AssociateLambdaFunctionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: AssociateLambdaFunctionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AssociateLambdaFunctionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1AssociateLambdaFunctionCommand(input, context);
+    };
+    AssociateLambdaFunctionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1AssociateLambdaFunctionCommand(output, context);
+    };
+    return AssociateLambdaFunctionCommand;
+}($Command));
+export { AssociateLambdaFunctionCommand };

package/dist-es/commands/AssociateLexBotCommand.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 { AssociateLexBotRequest } from "../models/models_0";
+import { deserializeAws_restJson1AssociateLexBotCommand, serializeAws_restJson1AssociateLexBotCommand, } from "../protocols/Aws_restJson1";
+var AssociateLexBotCommand = (function (_super) {
+    __extends(AssociateLexBotCommand, _super);
+    function AssociateLexBotCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    AssociateLexBotCommand.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 = "AssociateLexBotCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: AssociateLexBotRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AssociateLexBotCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1AssociateLexBotCommand(input, context);
+    };
+    AssociateLexBotCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1AssociateLexBotCommand(output, context);
+    };
+    return AssociateLexBotCommand;
+}($Command));
+export { AssociateLexBotCommand };

package/dist-es/commands/AssociateQueueQuickConnectsCommand.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 { AssociateQueueQuickConnectsRequest } from "../models/models_0";
+import { deserializeAws_restJson1AssociateQueueQuickConnectsCommand, serializeAws_restJson1AssociateQueueQuickConnectsCommand, } from "../protocols/Aws_restJson1";
+var AssociateQueueQuickConnectsCommand = (function (_super) {
+    __extends(AssociateQueueQuickConnectsCommand, _super);
+    function AssociateQueueQuickConnectsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    AssociateQueueQuickConnectsCommand.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 = "AssociateQueueQuickConnectsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: AssociateQueueQuickConnectsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AssociateQueueQuickConnectsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1AssociateQueueQuickConnectsCommand(input, context);
+    };
+    AssociateQueueQuickConnectsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1AssociateQueueQuickConnectsCommand(output, context);
+    };
+    return AssociateQueueQuickConnectsCommand;
+}($Command));
+export { AssociateQueueQuickConnectsCommand };

package/dist-es/commands/AssociateRoutingProfileQueuesCommand.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 { AssociateRoutingProfileQueuesRequest } from "../models/models_0";
+import { deserializeAws_restJson1AssociateRoutingProfileQueuesCommand, serializeAws_restJson1AssociateRoutingProfileQueuesCommand, } from "../protocols/Aws_restJson1";
+var AssociateRoutingProfileQueuesCommand = (function (_super) {
+    __extends(AssociateRoutingProfileQueuesCommand, _super);
+    function AssociateRoutingProfileQueuesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    AssociateRoutingProfileQueuesCommand.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 = "AssociateRoutingProfileQueuesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: AssociateRoutingProfileQueuesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AssociateRoutingProfileQueuesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1AssociateRoutingProfileQueuesCommand(input, context);
+    };
+    AssociateRoutingProfileQueuesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1AssociateRoutingProfileQueuesCommand(output, context);
+    };
+    return AssociateRoutingProfileQueuesCommand;
+}($Command));
+export { AssociateRoutingProfileQueuesCommand };

package/dist-es/commands/AssociateSecurityKeyCommand.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 { AssociateSecurityKeyRequest, AssociateSecurityKeyResponse } from "../models/models_0";
+import { deserializeAws_restJson1AssociateSecurityKeyCommand, serializeAws_restJson1AssociateSecurityKeyCommand, } from "../protocols/Aws_restJson1";
+var AssociateSecurityKeyCommand = (function (_super) {
+    __extends(AssociateSecurityKeyCommand, _super);
+    function AssociateSecurityKeyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    AssociateSecurityKeyCommand.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 = "AssociateSecurityKeyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: AssociateSecurityKeyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: AssociateSecurityKeyResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AssociateSecurityKeyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1AssociateSecurityKeyCommand(input, context);
+    };
+    AssociateSecurityKeyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1AssociateSecurityKeyCommand(output, context);
+    };
+    return AssociateSecurityKeyCommand;
+}($Command));
+export { AssociateSecurityKeyCommand };

package/dist-es/commands/CreateAgentStatusCommand.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 { CreateAgentStatusRequest, CreateAgentStatusResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateAgentStatusCommand, serializeAws_restJson1CreateAgentStatusCommand, } from "../protocols/Aws_restJson1";
+var CreateAgentStatusCommand = (function (_super) {
+    __extends(CreateAgentStatusCommand, _super);
+    function CreateAgentStatusCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateAgentStatusCommand.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 = "CreateAgentStatusCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateAgentStatusRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateAgentStatusResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateAgentStatusCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateAgentStatusCommand(input, context);
+    };
+    CreateAgentStatusCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateAgentStatusCommand(output, context);
+    };
+    return CreateAgentStatusCommand;
+}($Command));
+export { CreateAgentStatusCommand };

package/dist-es/commands/CreateContactFlowCommand.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 { CreateContactFlowRequest, CreateContactFlowResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateContactFlowCommand, serializeAws_restJson1CreateContactFlowCommand, } from "../protocols/Aws_restJson1";
+var CreateContactFlowCommand = (function (_super) {
+    __extends(CreateContactFlowCommand, _super);
+    function CreateContactFlowCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateContactFlowCommand.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 = "CreateContactFlowCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateContactFlowRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateContactFlowResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateContactFlowCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateContactFlowCommand(input, context);
+    };
+    CreateContactFlowCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateContactFlowCommand(output, context);
+    };
+    return CreateContactFlowCommand;
+}($Command));
+export { CreateContactFlowCommand };

package/dist-es/commands/CreateHoursOfOperationCommand.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 { CreateHoursOfOperationRequest, CreateHoursOfOperationResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateHoursOfOperationCommand, serializeAws_restJson1CreateHoursOfOperationCommand, } from "../protocols/Aws_restJson1";
+var CreateHoursOfOperationCommand = (function (_super) {
+    __extends(CreateHoursOfOperationCommand, _super);
+    function CreateHoursOfOperationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateHoursOfOperationCommand.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 = "CreateHoursOfOperationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateHoursOfOperationRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateHoursOfOperationResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateHoursOfOperationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateHoursOfOperationCommand(input, context);
+    };
+    CreateHoursOfOperationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateHoursOfOperationCommand(output, context);
+    };
+    return CreateHoursOfOperationCommand;
+}($Command));
+export { CreateHoursOfOperationCommand };

package/dist-es/commands/CreateInstanceCommand.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 { CreateInstanceRequest, CreateInstanceResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateInstanceCommand, serializeAws_restJson1CreateInstanceCommand, } from "../protocols/Aws_restJson1";
+var CreateInstanceCommand = (function (_super) {
+    __extends(CreateInstanceCommand, _super);
+    function CreateInstanceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateInstanceCommand.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 = "CreateInstanceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateInstanceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateInstanceResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateInstanceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateInstanceCommand(input, context);
+    };
+    CreateInstanceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateInstanceCommand(output, context);
+    };
+    return CreateInstanceCommand;
+}($Command));
+export { CreateInstanceCommand };

package/dist-es/commands/CreateIntegrationAssociationCommand.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 { CreateIntegrationAssociationRequest, CreateIntegrationAssociationResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateIntegrationAssociationCommand, serializeAws_restJson1CreateIntegrationAssociationCommand, } from "../protocols/Aws_restJson1";
+var CreateIntegrationAssociationCommand = (function (_super) {
+    __extends(CreateIntegrationAssociationCommand, _super);
+    function CreateIntegrationAssociationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateIntegrationAssociationCommand.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 = "CreateIntegrationAssociationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateIntegrationAssociationRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateIntegrationAssociationResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateIntegrationAssociationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateIntegrationAssociationCommand(input, context);
+    };
+    CreateIntegrationAssociationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateIntegrationAssociationCommand(output, context);
+    };
+    return CreateIntegrationAssociationCommand;
+}($Command));
+export { CreateIntegrationAssociationCommand };

package/dist-es/commands/CreateQueueCommand.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 { CreateQueueRequest, CreateQueueResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateQueueCommand, serializeAws_restJson1CreateQueueCommand, } from "../protocols/Aws_restJson1";
+var CreateQueueCommand = (function (_super) {
+    __extends(CreateQueueCommand, _super);
+    function CreateQueueCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateQueueCommand.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 = "CreateQueueCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateQueueRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateQueueResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateQueueCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateQueueCommand(input, context);
+    };
+    CreateQueueCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateQueueCommand(output, context);
+    };
+    return CreateQueueCommand;
+}($Command));
+export { CreateQueueCommand };

package/dist-es/commands/CreateQuickConnectCommand.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 { CreateQuickConnectRequest, CreateQuickConnectResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateQuickConnectCommand, serializeAws_restJson1CreateQuickConnectCommand, } from "../protocols/Aws_restJson1";
+var CreateQuickConnectCommand = (function (_super) {
+    __extends(CreateQuickConnectCommand, _super);
+    function CreateQuickConnectCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateQuickConnectCommand.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 = "CreateQuickConnectCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateQuickConnectRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateQuickConnectResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateQuickConnectCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateQuickConnectCommand(input, context);
+    };
+    CreateQuickConnectCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateQuickConnectCommand(output, context);
+    };
+    return CreateQuickConnectCommand;
+}($Command));
+export { CreateQuickConnectCommand };