@aws-sdk/client-connect 3.34.0 → 3.37.0

package/dist-types/commands/UpdateInstanceStorageConfigCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectClient";
+import { UpdateInstanceStorageConfigRequest } from "../models/models_0";
+export interface UpdateInstanceStorageConfigCommandInput extends UpdateInstanceStorageConfigRequest {
+}
+export interface UpdateInstanceStorageConfigCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>This API is in preview release for Amazon Connect and is subject to change.</p>
+ *          <p>Updates an existing configuration for a resource type. This API is idempotent.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, UpdateInstanceStorageConfigCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, UpdateInstanceStorageConfigCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new UpdateInstanceStorageConfigCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateInstanceStorageConfigCommandInput} for command's `input` shape.
+ * @see {@link UpdateInstanceStorageConfigCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateInstanceStorageConfigCommand extends $Command<UpdateInstanceStorageConfigCommandInput, UpdateInstanceStorageConfigCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: UpdateInstanceStorageConfigCommandInput;
+    constructor(input: UpdateInstanceStorageConfigCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateInstanceStorageConfigCommandInput, UpdateInstanceStorageConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateQueueHoursOfOperationCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectClient";
+import { UpdateQueueHoursOfOperationRequest } from "../models/models_0";
+export interface UpdateQueueHoursOfOperationCommandInput extends UpdateQueueHoursOfOperationRequest {
+}
+export interface UpdateQueueHoursOfOperationCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>This API is in preview release for Amazon Connect and is subject to change.</p>
+ *          <p>Updates the hours of operation for the specified queue.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, UpdateQueueHoursOfOperationCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, UpdateQueueHoursOfOperationCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new UpdateQueueHoursOfOperationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateQueueHoursOfOperationCommandInput} for command's `input` shape.
+ * @see {@link UpdateQueueHoursOfOperationCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateQueueHoursOfOperationCommand extends $Command<UpdateQueueHoursOfOperationCommandInput, UpdateQueueHoursOfOperationCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: UpdateQueueHoursOfOperationCommandInput;
+    constructor(input: UpdateQueueHoursOfOperationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateQueueHoursOfOperationCommandInput, UpdateQueueHoursOfOperationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateQueueMaxContactsCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectClient";
+import { UpdateQueueMaxContactsRequest } from "../models/models_0";
+export interface UpdateQueueMaxContactsCommandInput extends UpdateQueueMaxContactsRequest {
+}
+export interface UpdateQueueMaxContactsCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>This API is in preview release for Amazon Connect and is subject to change.</p>
+ *          <p>Updates the maximum number of contacts allowed in a queue before it is considered
+ *    full.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, UpdateQueueMaxContactsCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, UpdateQueueMaxContactsCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new UpdateQueueMaxContactsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateQueueMaxContactsCommandInput} for command's `input` shape.
+ * @see {@link UpdateQueueMaxContactsCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateQueueMaxContactsCommand extends $Command<UpdateQueueMaxContactsCommandInput, UpdateQueueMaxContactsCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: UpdateQueueMaxContactsCommandInput;
+    constructor(input: UpdateQueueMaxContactsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateQueueMaxContactsCommandInput, UpdateQueueMaxContactsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateQueueNameCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectClient";
+import { UpdateQueueNameRequest } from "../models/models_0";
+export interface UpdateQueueNameCommandInput extends UpdateQueueNameRequest {
+}
+export interface UpdateQueueNameCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>This API is in preview release for Amazon Connect and is subject to change.</p>
+ *          <p>Updates the name and description of a queue. At least <code>Name</code> or <code>Description</code> must be provided.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, UpdateQueueNameCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, UpdateQueueNameCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new UpdateQueueNameCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateQueueNameCommandInput} for command's `input` shape.
+ * @see {@link UpdateQueueNameCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateQueueNameCommand extends $Command<UpdateQueueNameCommandInput, UpdateQueueNameCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: UpdateQueueNameCommandInput;
+    constructor(input: UpdateQueueNameCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateQueueNameCommandInput, UpdateQueueNameCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateQueueOutboundCallerConfigCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectClient";
+import { UpdateQueueOutboundCallerConfigRequest } from "../models/models_0";
+export interface UpdateQueueOutboundCallerConfigCommandInput extends UpdateQueueOutboundCallerConfigRequest {
+}
+export interface UpdateQueueOutboundCallerConfigCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>This API is in preview release for Amazon Connect and is subject to change.</p>
+ *          <p>Updates the outbound caller ID name, number, and outbound whisper flow for a specified
+ *    queue.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, UpdateQueueOutboundCallerConfigCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, UpdateQueueOutboundCallerConfigCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new UpdateQueueOutboundCallerConfigCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateQueueOutboundCallerConfigCommandInput} for command's `input` shape.
+ * @see {@link UpdateQueueOutboundCallerConfigCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateQueueOutboundCallerConfigCommand extends $Command<UpdateQueueOutboundCallerConfigCommandInput, UpdateQueueOutboundCallerConfigCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: UpdateQueueOutboundCallerConfigCommandInput;
+    constructor(input: UpdateQueueOutboundCallerConfigCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateQueueOutboundCallerConfigCommandInput, UpdateQueueOutboundCallerConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateQueueStatusCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectClient";
+import { UpdateQueueStatusRequest } from "../models/models_0";
+export interface UpdateQueueStatusCommandInput extends UpdateQueueStatusRequest {
+}
+export interface UpdateQueueStatusCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>This API is in preview release for Amazon Connect and is subject to change.</p>
+ *          <p>Updates the status of the queue.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, UpdateQueueStatusCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, UpdateQueueStatusCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new UpdateQueueStatusCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateQueueStatusCommandInput} for command's `input` shape.
+ * @see {@link UpdateQueueStatusCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateQueueStatusCommand extends $Command<UpdateQueueStatusCommandInput, UpdateQueueStatusCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: UpdateQueueStatusCommandInput;
+    constructor(input: UpdateQueueStatusCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateQueueStatusCommandInput, UpdateQueueStatusCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateQuickConnectConfigCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectClient";
+import { UpdateQuickConnectConfigRequest } from "../models/models_0";
+export interface UpdateQuickConnectConfigCommandInput extends UpdateQuickConnectConfigRequest {
+}
+export interface UpdateQuickConnectConfigCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Updates the configuration settings for the specified quick connect.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, UpdateQuickConnectConfigCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, UpdateQuickConnectConfigCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new UpdateQuickConnectConfigCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateQuickConnectConfigCommandInput} for command's `input` shape.
+ * @see {@link UpdateQuickConnectConfigCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateQuickConnectConfigCommand extends $Command<UpdateQuickConnectConfigCommandInput, UpdateQuickConnectConfigCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: UpdateQuickConnectConfigCommandInput;
+    constructor(input: UpdateQuickConnectConfigCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateQuickConnectConfigCommandInput, UpdateQuickConnectConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateQuickConnectNameCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectClient";
+import { UpdateQuickConnectNameRequest } from "../models/models_0";
+export interface UpdateQuickConnectNameCommandInput extends UpdateQuickConnectNameRequest {
+}
+export interface UpdateQuickConnectNameCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Updates the name and description of a quick connect. The request accepts the following data in JSON format. At least <code>Name</code> or <code>Description</code> must be provided.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, UpdateQuickConnectNameCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, UpdateQuickConnectNameCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new UpdateQuickConnectNameCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateQuickConnectNameCommandInput} for command's `input` shape.
+ * @see {@link UpdateQuickConnectNameCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateQuickConnectNameCommand extends $Command<UpdateQuickConnectNameCommandInput, UpdateQuickConnectNameCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: UpdateQuickConnectNameCommandInput;
+    constructor(input: UpdateQuickConnectNameCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateQuickConnectNameCommandInput, UpdateQuickConnectNameCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateRoutingProfileConcurrencyCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectClient";
+import { UpdateRoutingProfileConcurrencyRequest } from "../models/models_0";
+export interface UpdateRoutingProfileConcurrencyCommandInput extends UpdateRoutingProfileConcurrencyRequest {
+}
+export interface UpdateRoutingProfileConcurrencyCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Updates the channels that agents can handle in the Contact Control Panel (CCP) for a routing
+ *    profile.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, UpdateRoutingProfileConcurrencyCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, UpdateRoutingProfileConcurrencyCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new UpdateRoutingProfileConcurrencyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateRoutingProfileConcurrencyCommandInput} for command's `input` shape.
+ * @see {@link UpdateRoutingProfileConcurrencyCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateRoutingProfileConcurrencyCommand extends $Command<UpdateRoutingProfileConcurrencyCommandInput, UpdateRoutingProfileConcurrencyCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: UpdateRoutingProfileConcurrencyCommandInput;
+    constructor(input: UpdateRoutingProfileConcurrencyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateRoutingProfileConcurrencyCommandInput, UpdateRoutingProfileConcurrencyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateRoutingProfileDefaultOutboundQueueCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectClient";
+import { UpdateRoutingProfileDefaultOutboundQueueRequest } from "../models/models_0";
+export interface UpdateRoutingProfileDefaultOutboundQueueCommandInput extends UpdateRoutingProfileDefaultOutboundQueueRequest {
+}
+export interface UpdateRoutingProfileDefaultOutboundQueueCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Updates the default outbound queue of a routing profile.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, UpdateRoutingProfileDefaultOutboundQueueCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, UpdateRoutingProfileDefaultOutboundQueueCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new UpdateRoutingProfileDefaultOutboundQueueCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateRoutingProfileDefaultOutboundQueueCommandInput} for command's `input` shape.
+ * @see {@link UpdateRoutingProfileDefaultOutboundQueueCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateRoutingProfileDefaultOutboundQueueCommand extends $Command<UpdateRoutingProfileDefaultOutboundQueueCommandInput, UpdateRoutingProfileDefaultOutboundQueueCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: UpdateRoutingProfileDefaultOutboundQueueCommandInput;
+    constructor(input: UpdateRoutingProfileDefaultOutboundQueueCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateRoutingProfileDefaultOutboundQueueCommandInput, UpdateRoutingProfileDefaultOutboundQueueCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateRoutingProfileNameCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectClient";
+import { UpdateRoutingProfileNameRequest } from "../models/models_0";
+export interface UpdateRoutingProfileNameCommandInput extends UpdateRoutingProfileNameRequest {
+}
+export interface UpdateRoutingProfileNameCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Updates the name and description of a routing profile. The request accepts the following data in JSON format.
+ *    At least <code>Name</code> or <code>Description</code> must be provided.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, UpdateRoutingProfileNameCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, UpdateRoutingProfileNameCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new UpdateRoutingProfileNameCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateRoutingProfileNameCommandInput} for command's `input` shape.
+ * @see {@link UpdateRoutingProfileNameCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateRoutingProfileNameCommand extends $Command<UpdateRoutingProfileNameCommandInput, UpdateRoutingProfileNameCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: UpdateRoutingProfileNameCommandInput;
+    constructor(input: UpdateRoutingProfileNameCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateRoutingProfileNameCommandInput, UpdateRoutingProfileNameCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateRoutingProfileQueuesCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectClient";
+import { UpdateRoutingProfileQueuesRequest } from "../models/models_0";
+export interface UpdateRoutingProfileQueuesCommandInput extends UpdateRoutingProfileQueuesRequest {
+}
+export interface UpdateRoutingProfileQueuesCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Updates the properties associated with a set of queues for a routing profile.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, UpdateRoutingProfileQueuesCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, UpdateRoutingProfileQueuesCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new UpdateRoutingProfileQueuesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateRoutingProfileQueuesCommandInput} for command's `input` shape.
+ * @see {@link UpdateRoutingProfileQueuesCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateRoutingProfileQueuesCommand extends $Command<UpdateRoutingProfileQueuesCommandInput, UpdateRoutingProfileQueuesCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: UpdateRoutingProfileQueuesCommandInput;
+    constructor(input: UpdateRoutingProfileQueuesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateRoutingProfileQueuesCommandInput, UpdateRoutingProfileQueuesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateUserHierarchyCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectClient";
+import { UpdateUserHierarchyRequest } from "../models/models_0";
+export interface UpdateUserHierarchyCommandInput extends UpdateUserHierarchyRequest {
+}
+export interface UpdateUserHierarchyCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Assigns the specified hierarchy group to the specified user.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, UpdateUserHierarchyCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, UpdateUserHierarchyCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new UpdateUserHierarchyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateUserHierarchyCommandInput} for command's `input` shape.
+ * @see {@link UpdateUserHierarchyCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateUserHierarchyCommand extends $Command<UpdateUserHierarchyCommandInput, UpdateUserHierarchyCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: UpdateUserHierarchyCommandInput;
+    constructor(input: UpdateUserHierarchyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateUserHierarchyCommandInput, UpdateUserHierarchyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateUserHierarchyGroupNameCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectClient";
+import { UpdateUserHierarchyGroupNameRequest } from "../models/models_0";
+export interface UpdateUserHierarchyGroupNameCommandInput extends UpdateUserHierarchyGroupNameRequest {
+}
+export interface UpdateUserHierarchyGroupNameCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Updates the name of the user hierarchy group. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, UpdateUserHierarchyGroupNameCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, UpdateUserHierarchyGroupNameCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new UpdateUserHierarchyGroupNameCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateUserHierarchyGroupNameCommandInput} for command's `input` shape.
+ * @see {@link UpdateUserHierarchyGroupNameCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateUserHierarchyGroupNameCommand extends $Command<UpdateUserHierarchyGroupNameCommandInput, UpdateUserHierarchyGroupNameCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: UpdateUserHierarchyGroupNameCommandInput;
+    constructor(input: UpdateUserHierarchyGroupNameCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateUserHierarchyGroupNameCommandInput, UpdateUserHierarchyGroupNameCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateUserHierarchyStructureCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectClient";
+import { UpdateUserHierarchyStructureRequest } from "../models/models_0";
+export interface UpdateUserHierarchyStructureCommandInput extends UpdateUserHierarchyStructureRequest {
+}
+export interface UpdateUserHierarchyStructureCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Updates the user hierarchy structure: add, remove, and rename user hierarchy levels.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, UpdateUserHierarchyStructureCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, UpdateUserHierarchyStructureCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new UpdateUserHierarchyStructureCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateUserHierarchyStructureCommandInput} for command's `input` shape.
+ * @see {@link UpdateUserHierarchyStructureCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateUserHierarchyStructureCommand extends $Command<UpdateUserHierarchyStructureCommandInput, UpdateUserHierarchyStructureCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: UpdateUserHierarchyStructureCommandInput;
+    constructor(input: UpdateUserHierarchyStructureCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateUserHierarchyStructureCommandInput, UpdateUserHierarchyStructureCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateUserIdentityInfoCommand.d.ts

@@ -0,0 +1,43 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectClient";
+import { UpdateUserIdentityInfoRequest } from "../models/models_0";
+export interface UpdateUserIdentityInfoCommandInput extends UpdateUserIdentityInfoRequest {
+}
+export interface UpdateUserIdentityInfoCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Updates the identity information for the specified user.</p>
+ *          <important>
+ *             <p>We strongly recommend limiting who has the ability to invoke
+ *      <code>UpdateUserIdentityInfo</code>. Someone with that ability can change the login credentials
+ *     of other users by changing their email address. This poses a security risk to your organization.
+ *     They can change the email address of a user to the attacker's email address, and then reset the
+ *     password through email. For more information, see <a href="https://docs.aws.amazon.com/connect/latest/adminguide/security-profile-best-practices.html">Best Practices for
+ *      Security Profiles</a> in the <i>Amazon Connect Administrator Guide</i>.</p>
+ *          </important>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, UpdateUserIdentityInfoCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, UpdateUserIdentityInfoCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new UpdateUserIdentityInfoCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateUserIdentityInfoCommandInput} for command's `input` shape.
+ * @see {@link UpdateUserIdentityInfoCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateUserIdentityInfoCommand extends $Command<UpdateUserIdentityInfoCommandInput, UpdateUserIdentityInfoCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: UpdateUserIdentityInfoCommandInput;
+    constructor(input: UpdateUserIdentityInfoCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateUserIdentityInfoCommandInput, UpdateUserIdentityInfoCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateUserPhoneConfigCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConnectClient";
+import { UpdateUserPhoneConfigRequest } from "../models/models_0";
+export interface UpdateUserPhoneConfigCommandInput extends UpdateUserPhoneConfigRequest {
+}
+export interface UpdateUserPhoneConfigCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Updates the phone configuration settings for the specified user.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, UpdateUserPhoneConfigCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, UpdateUserPhoneConfigCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new UpdateUserPhoneConfigCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateUserPhoneConfigCommandInput} for command's `input` shape.
+ * @see {@link UpdateUserPhoneConfigCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateUserPhoneConfigCommand extends $Command<UpdateUserPhoneConfigCommandInput, UpdateUserPhoneConfigCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: UpdateUserPhoneConfigCommandInput;
+    constructor(input: UpdateUserPhoneConfigCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateUserPhoneConfigCommandInput, UpdateUserPhoneConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}