@aws-sdk/client-connect 3.34.0 → 3.37.0

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

package/dist-types/commands/DescribeContactFlowCommand.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 { DescribeContactFlowRequest, DescribeContactFlowResponse } from "../models/models_0";
+export interface DescribeContactFlowCommandInput extends DescribeContactFlowRequest {
+}
+export interface DescribeContactFlowCommandOutput extends DescribeContactFlowResponse, __MetadataBearer {
+}
+/**
+ * <p>Describes 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, DescribeContactFlowCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, DescribeContactFlowCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new DescribeContactFlowCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeContactFlowCommandInput} for command's `input` shape.
+ * @see {@link DescribeContactFlowCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeContactFlowCommand extends $Command<DescribeContactFlowCommandInput, DescribeContactFlowCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: DescribeContactFlowCommandInput;
+    constructor(input: DescribeContactFlowCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeContactFlowCommandInput, DescribeContactFlowCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

package/dist-types/commands/DescribeInstanceCommand.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 { DescribeInstanceRequest, DescribeInstanceResponse } from "../models/models_0";
+export interface DescribeInstanceCommandInput extends DescribeInstanceRequest {
+}
+export interface DescribeInstanceCommandOutput extends DescribeInstanceResponse, __MetadataBearer {
+}
+/**
+ * <p>This API is in preview release for Amazon Connect and is subject to change.</p>
+ *          <p>Returns the current state of the specified instance identifier. It tracks the instance while
+ *    it is being created and returns an error status, if applicable. </p>
+ *          <p>If an instance is not created successfully, the instance status reason field returns details
+ *    relevant to the reason. The instance in a failed state is returned only for 24 hours after the
+ *    CreateInstance API was invoked.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, DescribeInstanceCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, DescribeInstanceCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new DescribeInstanceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeInstanceCommandInput} for command's `input` shape.
+ * @see {@link DescribeInstanceCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeInstanceCommand extends $Command<DescribeInstanceCommandInput, DescribeInstanceCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: DescribeInstanceCommandInput;
+    constructor(input: DescribeInstanceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeInstanceCommandInput, DescribeInstanceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

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

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

package/dist-types/commands/DescribeUserCommand.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 { DescribeUserRequest, DescribeUserResponse } from "../models/models_0";
+export interface DescribeUserCommandInput extends DescribeUserRequest {
+}
+export interface DescribeUserCommandOutput extends DescribeUserResponse, __MetadataBearer {
+}
+/**
+ * <p>Describes the specified user account. You can find the instance ID in the console (it’s the
+ *    final part of the ARN). The console does not display the user IDs. Instead, list the users and
+ *    note the IDs provided in the output.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, DescribeUserCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, DescribeUserCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new DescribeUserCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeUserCommandInput} for command's `input` shape.
+ * @see {@link DescribeUserCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeUserCommand extends $Command<DescribeUserCommandInput, DescribeUserCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: DescribeUserCommandInput;
+    constructor(input: DescribeUserCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeUserCommandInput, DescribeUserCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

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

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

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

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

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