@aws-sdk/client-connect 3.34.0 → 3.35.0

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

@@ -0,0 +1,55 @@
+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 { StartChatContactRequest, StartChatContactResponse } from "../models/models_0";
+export interface StartChatContactCommandInput extends StartChatContactRequest {
+}
+export interface StartChatContactCommandOutput extends StartChatContactResponse, __MetadataBearer {
+}
+/**
+ * <p>Initiates a contact flow to start a new chat for the customer. Response of this API provides
+ *    a token required to obtain credentials from the <a href="https://docs.aws.amazon.com/connect-participant/latest/APIReference/API_CreateParticipantConnection.html">CreateParticipantConnection</a> API in the Amazon Connect Participant Service.</p>
+ *
+ *          <p>When a new chat contact is successfully created, clients must subscribe to the participant’s
+ *    connection for the created chat within 5 minutes. This is achieved by invoking <a href="https://docs.aws.amazon.com/connect-participant/latest/APIReference/API_CreateParticipantConnection.html">CreateParticipantConnection</a> with WEBSOCKET and CONNECTION_CREDENTIALS. </p>
+ *
+ *          <p>A 429 error occurs in two situations:</p>
+ *          <ul>
+ *             <li>
+ *                <p>API rate limit is exceeded. API TPS throttling returns a <code>TooManyRequests</code>
+ *      exception.</p>
+ *             </li>
+ *             <li>
+ *                <p>The <a href="https://docs.aws.amazon.com/connect/latest/adminguide/amazon-connect-service-limits.html">quota for concurrent active
+ *       chats</a> is exceeded. Active chat throttling returns a
+ *       <code>LimitExceededException</code>.</p>
+ *             </li>
+ *          </ul>
+ *
+ *          <p>For more information about chat, see <a href="https://docs.aws.amazon.com/connect/latest/adminguide/chat.html">Chat</a> in the <i>Amazon Connect Administrator
+ *     Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, StartChatContactCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, StartChatContactCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new StartChatContactCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StartChatContactCommandInput} for command's `input` shape.
+ * @see {@link StartChatContactCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class StartChatContactCommand extends $Command<StartChatContactCommandInput, StartChatContactCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: StartChatContactCommandInput;
+    constructor(input: StartChatContactCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartChatContactCommandInput, StartChatContactCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,42 @@
+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 { StartContactRecordingRequest, StartContactRecordingResponse } from "../models/models_0";
+export interface StartContactRecordingCommandInput extends StartContactRecordingRequest {
+}
+export interface StartContactRecordingCommandOutput extends StartContactRecordingResponse, __MetadataBearer {
+}
+/**
+ * <p>Starts recording the contact when the agent joins the call. StartContactRecording is a
+ *    one-time action. For example, if you use StopContactRecording to stop recording an ongoing call,
+ *    you can't use StartContactRecording to restart it. For scenarios where the recording has started
+ *    and you want to suspend and resume it, such as when collecting sensitive information (for
+ *    example, a credit card number), use SuspendContactRecording and ResumeContactRecording.</p>
+ *          <p>You can use this API to override the recording behavior configured in the <a href="https://docs.aws.amazon.com/connect/latest/adminguide/set-recording-behavior.html">Set recording
+ *     behavior</a> block.</p>
+ *          <p>Only voice recordings are supported at this time.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, StartContactRecordingCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, StartContactRecordingCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new StartContactRecordingCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StartContactRecordingCommandInput} for command's `input` shape.
+ * @see {@link StartContactRecordingCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class StartContactRecordingCommand extends $Command<StartContactRecordingCommandInput, StartContactRecordingCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: StartContactRecordingCommandInput;
+    constructor(input: StartContactRecordingCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartContactRecordingCommandInput, StartContactRecordingCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,53 @@
+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 { StartOutboundVoiceContactRequest, StartOutboundVoiceContactResponse } from "../models/models_0";
+export interface StartOutboundVoiceContactCommandInput extends StartOutboundVoiceContactRequest {
+}
+export interface StartOutboundVoiceContactCommandOutput extends StartOutboundVoiceContactResponse, __MetadataBearer {
+}
+/**
+ * <p>Places an outbound call to a contact, and then initiates the contact flow. It performs the
+ *    actions in the contact flow that's specified (in <code>ContactFlowId</code>).</p>
+ *
+ *          <p>Agents do not initiate the outbound API, which means that they do not dial the contact. If
+ *    the contact flow places an outbound call to a contact, and then puts the contact in queue, the
+ *    call is then routed to the agent, like any other inbound case.</p>
+ *
+ *          <p>There is a 60-second dialing timeout for this operation. If the call is not connected after
+ *    60 seconds, it fails.</p>
+ *          <note>
+ *             <p>UK numbers with a 447 prefix are not allowed by default. Before you can dial these UK
+ *     mobile numbers, you must submit a service quota increase request. For more information, see
+ *      <a href="https://docs.aws.amazon.com/connect/latest/adminguide/amazon-connect-service-limits.html">Amazon Connect Service Quotas</a> in the <i>Amazon Connect Administrator Guide</i>. </p>
+ *          </note>
+ *          <note>
+ *             <p>Campaign calls are not allowed by default. Before you can make a call with
+ *     <code>TrafficType</code> = <code>CAMPAIGN</code>, you must submit a service quota increase request. For more information, see
+ *     <a href="https://docs.aws.amazon.com/connect/latest/adminguide/amazon-connect-service-limits.html">Amazon Connect Service Quotas</a> in the <i>Amazon Connect Administrator Guide</i>. </p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, StartOutboundVoiceContactCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, StartOutboundVoiceContactCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new StartOutboundVoiceContactCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StartOutboundVoiceContactCommandInput} for command's `input` shape.
+ * @see {@link StartOutboundVoiceContactCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class StartOutboundVoiceContactCommand extends $Command<StartOutboundVoiceContactCommandInput, StartOutboundVoiceContactCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: StartOutboundVoiceContactCommandInput;
+    constructor(input: StartOutboundVoiceContactCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartOutboundVoiceContactCommandInput, StartOutboundVoiceContactCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/StartTaskContactCommand.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 { StartTaskContactRequest, StartTaskContactResponse } from "../models/models_0";
+export interface StartTaskContactCommandInput extends StartTaskContactRequest {
+}
+export interface StartTaskContactCommandOutput extends StartTaskContactResponse, __MetadataBearer {
+}
+/**
+ * <p>Initiates a contact flow to start a new task.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, StartTaskContactCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, StartTaskContactCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new StartTaskContactCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StartTaskContactCommandInput} for command's `input` shape.
+ * @see {@link StartTaskContactCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class StartTaskContactCommand extends $Command<StartTaskContactCommandInput, StartTaskContactCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: StartTaskContactCommandInput;
+    constructor(input: StartTaskContactCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartTaskContactCommandInput, StartTaskContactCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/StopContactCommand.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 { StopContactRequest, StopContactResponse } from "../models/models_0";
+export interface StopContactCommandInput extends StopContactRequest {
+}
+export interface StopContactCommandOutput extends StopContactResponse, __MetadataBearer {
+}
+/**
+ * <p>Ends the specified contact.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, StopContactCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, StopContactCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new StopContactCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StopContactCommandInput} for command's `input` shape.
+ * @see {@link StopContactCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class StopContactCommand extends $Command<StopContactCommandInput, StopContactCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: StopContactCommandInput;
+    constructor(input: StopContactCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopContactCommandInput, StopContactCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,41 @@
+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 { StopContactRecordingRequest, StopContactRecordingResponse } from "../models/models_0";
+export interface StopContactRecordingCommandInput extends StopContactRecordingRequest {
+}
+export interface StopContactRecordingCommandOutput extends StopContactRecordingResponse, __MetadataBearer {
+}
+/**
+ * <p>Stops recording a call when a contact is being recorded. StopContactRecording is a one-time
+ *    action. If you use StopContactRecording to stop recording an ongoing call, you can't use
+ *    StartContactRecording to restart it. For scenarios where the recording has started and you want
+ *    to suspend it for sensitive information (for example, to collect a credit card number), and then
+ *    restart it, use SuspendContactRecording and ResumeContactRecording.</p>
+ *
+ *          <p>Only voice recordings are supported at this time.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, StopContactRecordingCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, StopContactRecordingCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new StopContactRecordingCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StopContactRecordingCommandInput} for command's `input` shape.
+ * @see {@link StopContactRecordingCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class StopContactRecordingCommand extends $Command<StopContactRecordingCommandInput, StopContactRecordingCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: StopContactRecordingCommandInput;
+    constructor(input: StopContactRecordingCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopContactRecordingCommandInput, StopContactRecordingCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,40 @@
+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 { SuspendContactRecordingRequest, SuspendContactRecordingResponse } from "../models/models_0";
+export interface SuspendContactRecordingCommandInput extends SuspendContactRecordingRequest {
+}
+export interface SuspendContactRecordingCommandOutput extends SuspendContactRecordingResponse, __MetadataBearer {
+}
+/**
+ * <p>When a contact is being recorded, this API suspends recording the call. For example, you
+ *    might suspend the call recording while collecting sensitive information, such as a credit card
+ *    number. Then use ResumeContactRecording to restart recording. </p>
+ *          <p>The period of time that the recording is suspended is filled with silence in the final
+ *    recording. </p>
+ *          <p>Only voice recordings are supported at this time.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, SuspendContactRecordingCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, SuspendContactRecordingCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new SuspendContactRecordingCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SuspendContactRecordingCommandInput} for command's `input` shape.
+ * @see {@link SuspendContactRecordingCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class SuspendContactRecordingCommand extends $Command<SuspendContactRecordingCommandInput, SuspendContactRecordingCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: SuspendContactRecordingCommandInput;
+    constructor(input: SuspendContactRecordingCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SuspendContactRecordingCommandInput, SuspendContactRecordingCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,39 @@
+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 { TagResourceRequest } from "../models/models_0";
+export interface TagResourceCommandInput extends TagResourceRequest {
+}
+export interface TagResourceCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Adds the specified tags to the specified resource.</p>
+ *          <p>The supported resource types are users, routing profiles, queues, quick connects,
+ *    contact flows, agent status, and hours of operation.</p>
+ *          <p>For sample policies that use tags, see <a href="https://docs.aws.amazon.com/connect/latest/adminguide/security_iam_id-based-policy-examples.html">Amazon Connect Identity-Based
+ *     Policy Examples</a> in the <i>Amazon Connect Administrator Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, TagResourceCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, TagResourceCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new TagResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link TagResourceCommandInput} for command's `input` shape.
+ * @see {@link TagResourceCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: TagResourceCommandInput;
+    constructor(input: TagResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UntagResourceCommand.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 { UntagResourceRequest } from "../models/models_0";
+export interface UntagResourceCommandInput extends UntagResourceRequest {
+}
+export interface UntagResourceCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Removes the specified tags from the specified resource.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, UntagResourceCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, UntagResourceCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new UntagResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UntagResourceCommandInput} for command's `input` shape.
+ * @see {@link UntagResourceCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: UntagResourceCommandInput;
+    constructor(input: UntagResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateAgentStatusCommand.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 { UpdateAgentStatusRequest } from "../models/models_0";
+export interface UpdateAgentStatusCommandInput extends UpdateAgentStatusRequest {
+}
+export interface UpdateAgentStatusCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>This API is in preview release for Amazon Connect and is subject to change.</p>
+ *          <p>Updates agent status.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, UpdateAgentStatusCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, UpdateAgentStatusCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new UpdateAgentStatusCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateAgentStatusCommandInput} for command's `input` shape.
+ * @see {@link UpdateAgentStatusCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateAgentStatusCommand extends $Command<UpdateAgentStatusCommandInput, UpdateAgentStatusCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: UpdateAgentStatusCommandInput;
+    constructor(input: UpdateAgentStatusCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateAgentStatusCommandInput, UpdateAgentStatusCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,54 @@
+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 { UpdateContactAttributesRequest, UpdateContactAttributesResponse } from "../models/models_0";
+export interface UpdateContactAttributesCommandInput extends UpdateContactAttributesRequest {
+}
+export interface UpdateContactAttributesCommandOutput extends UpdateContactAttributesResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates or updates
+ *    user-defined contact attributes
+ *    associated with the specified contact.</p>
+ *          <p>You can create or update user-defined attributes for both ongoing and completed contacts.
+ *    For example, while the call is active, you can update the customer's name or the reason the
+ *    customer called. You can add notes about steps that the agent took during the call that display
+ *    to the next agent that takes the call. You can also update attributes for a contact using data
+ *    from your CRM application and save the data with the contact in Amazon Connect. You could also flag calls
+ *    for additional analysis, such as legal review or to identify abusive callers.</p>
+ *          <p>Contact attributes are available in Amazon Connect for 24 months, and are then deleted. For
+ *    information about CTR retention and the maximum size of the CTR attributes section, see <a href="https://docs.aws.amazon.com/connect/latest/adminguide/amazon-connect-service-limits.html#feature-limits">Feature
+ *     specifications</a> in the <i>Amazon Connect Administrator Guide</i>. </p>
+ *
+ *          <p>
+ *             <b>Important:</b> You cannot use the operation to update
+ *    attributes for contacts that occurred prior to the release of the API, which was September 12,
+ *    2018. You can update attributes only for contacts that started after the release of the API. If
+ *    you attempt to update attributes for a contact that occurred prior to the release of the API, a
+ *    400 error is returned. This applies also to queued callbacks that were initiated prior to the
+ *    release of the API but are still active in your instance.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, UpdateContactAttributesCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, UpdateContactAttributesCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new UpdateContactAttributesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateContactAttributesCommandInput} for command's `input` shape.
+ * @see {@link UpdateContactAttributesCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateContactAttributesCommand extends $Command<UpdateContactAttributesCommandInput, UpdateContactAttributesCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: UpdateContactAttributesCommandInput;
+    constructor(input: UpdateContactAttributesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateContactAttributesCommandInput, UpdateContactAttributesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateContactFlowContentCommand.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 { UpdateContactFlowContentRequest } from "../models/models_0";
+export interface UpdateContactFlowContentCommandInput extends UpdateContactFlowContentRequest {
+}
+export interface UpdateContactFlowContentCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Updates the specified contact flow.</p>
+ *          <p>You can also create and update contact flows using the <a href="https://docs.aws.amazon.com/connect/latest/adminguide/flow-language.html">Amazon Connect
+ *    Flow language</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, UpdateContactFlowContentCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, UpdateContactFlowContentCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new UpdateContactFlowContentCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateContactFlowContentCommandInput} for command's `input` shape.
+ * @see {@link UpdateContactFlowContentCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateContactFlowContentCommand extends $Command<UpdateContactFlowContentCommandInput, UpdateContactFlowContentCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: UpdateContactFlowContentCommandInput;
+    constructor(input: UpdateContactFlowContentCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateContactFlowContentCommandInput, UpdateContactFlowContentCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateContactFlowNameCommand.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 { UpdateContactFlowNameRequest } from "../models/models_0";
+export interface UpdateContactFlowNameCommandInput extends UpdateContactFlowNameRequest {
+}
+export interface UpdateContactFlowNameCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>The name of the contact flow.</p>
+ *          <p>You can also create and update contact flows using the <a href="https://docs.aws.amazon.com/connect/latest/adminguide/flow-language.html">Amazon Connect
+ *    Flow language</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, UpdateContactFlowNameCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, UpdateContactFlowNameCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new UpdateContactFlowNameCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateContactFlowNameCommandInput} for command's `input` shape.
+ * @see {@link UpdateContactFlowNameCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateContactFlowNameCommand extends $Command<UpdateContactFlowNameCommandInput, UpdateContactFlowNameCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: UpdateContactFlowNameCommandInput;
+    constructor(input: UpdateContactFlowNameCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateContactFlowNameCommandInput, UpdateContactFlowNameCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

package/dist-types/commands/UpdateInstanceAttributeCommand.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 { UpdateInstanceAttributeRequest } from "../models/models_0";
+export interface UpdateInstanceAttributeCommandInput extends UpdateInstanceAttributeRequest {
+}
+export interface UpdateInstanceAttributeCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>This API is in preview release for Amazon Connect and is subject to change.</p>
+ *          <p>Updates the value for the specified attribute type.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, UpdateInstanceAttributeCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, UpdateInstanceAttributeCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new UpdateInstanceAttributeCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateInstanceAttributeCommandInput} for command's `input` shape.
+ * @see {@link UpdateInstanceAttributeCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateInstanceAttributeCommand extends $Command<UpdateInstanceAttributeCommandInput, UpdateInstanceAttributeCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: UpdateInstanceAttributeCommandInput;
+    constructor(input: UpdateInstanceAttributeCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateInstanceAttributeCommandInput, UpdateInstanceAttributeCommandOutput>;
+    private serialize;
+    private deserialize;
+}