@aws-sdk/client-connect 3.34.0 → 3.37.0

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

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

package/dist-types/commands/CreateInstanceCommand.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 { CreateInstanceRequest, CreateInstanceResponse } from "../models/models_0";
+export interface CreateInstanceCommandInput extends CreateInstanceRequest {
+}
+export interface CreateInstanceCommandOutput extends CreateInstanceResponse, __MetadataBearer {
+}
+/**
+ * <p>This API is in preview release for Amazon Connect and is subject to change.</p>
+ *          <p>Initiates an Amazon Connect instance with all the supported channels enabled. It does not attach any
+ *    storage, such as Amazon Simple Storage Service (Amazon S3) or Amazon Kinesis. It also does not
+ *    allow for any configurations on features, such as Contact Lens for Amazon Connect. </p>
+ *          <p>Amazon Connect enforces a limit on the total number of instances that you can create or delete in 30 days.
+ * If you exceed this limit, you will get an error message indicating there has been an excessive number of attempts at creating or deleting instances.
+ * You must wait 30 days before you can restart creating and deleting instances in your account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, CreateInstanceCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, CreateInstanceCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new CreateInstanceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateInstanceCommandInput} for command's `input` shape.
+ * @see {@link CreateInstanceCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateInstanceCommand extends $Command<CreateInstanceCommandInput, CreateInstanceCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: CreateInstanceCommandInput;
+    constructor(input: CreateInstanceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateInstanceCommandInput, CreateInstanceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

package/dist-types/commands/CreateQueueCommand.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 { CreateQueueRequest, CreateQueueResponse } from "../models/models_0";
+export interface CreateQueueCommandInput extends CreateQueueRequest {
+}
+export interface CreateQueueCommandOutput extends CreateQueueResponse, __MetadataBearer {
+}
+/**
+ * <p>This API is in preview release for Amazon Connect and is subject to change.</p>
+ *          <p>Creates a new queue for 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, CreateQueueCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, CreateQueueCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new CreateQueueCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateQueueCommandInput} for command's `input` shape.
+ * @see {@link CreateQueueCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateQueueCommand extends $Command<CreateQueueCommandInput, CreateQueueCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: CreateQueueCommandInput;
+    constructor(input: CreateQueueCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateQueueCommandInput, CreateQueueCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

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

package/dist-types/commands/CreateUserCommand.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 { CreateUserRequest, CreateUserResponse } from "../models/models_0";
+export interface CreateUserCommandInput extends CreateUserRequest {
+}
+export interface CreateUserCommandOutput extends CreateUserResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a user account for the specified Amazon Connect instance.</p>
+ *          <p>For information about how to create user accounts using the Amazon Connect console, see <a href="https://docs.aws.amazon.com/connect/latest/adminguide/user-management.html">Add Users</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, CreateUserCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, CreateUserCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new CreateUserCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateUserCommandInput} for command's `input` shape.
+ * @see {@link CreateUserCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateUserCommand extends $Command<CreateUserCommandInput, CreateUserCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: CreateUserCommandInput;
+    constructor(input: CreateUserCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateUserCommandInput, CreateUserCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

package/dist-types/commands/DeleteInstanceCommand.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 { DeleteInstanceRequest } from "../models/models_0";
+export interface DeleteInstanceCommandInput extends DeleteInstanceRequest {
+}
+export interface DeleteInstanceCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>This API is in preview release for Amazon Connect and is subject to change.</p>
+ *          <p>Deletes the Amazon Connect instance.</p>
+ *          <p>Amazon Connect enforces a limit on the total number of instances that you can create or delete in 30 days.
+ * If you exceed this limit, you will get an error message indicating there has been an excessive number of attempts at creating or deleting instances.
+ * You must wait 30 days before you can restart creating and deleting instances in your account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, DeleteInstanceCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, DeleteInstanceCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new DeleteInstanceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteInstanceCommandInput} for command's `input` shape.
+ * @see {@link DeleteInstanceCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteInstanceCommand extends $Command<DeleteInstanceCommandInput, DeleteInstanceCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: DeleteInstanceCommandInput;
+    constructor(input: DeleteInstanceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteInstanceCommandInput, DeleteInstanceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteIntegrationAssociationCommand.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 { DeleteIntegrationAssociationRequest } from "../models/models_0";
+export interface DeleteIntegrationAssociationCommandInput extends DeleteIntegrationAssociationRequest {
+}
+export interface DeleteIntegrationAssociationCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Deletes an AWS resource association from an Amazon Connect instance. The association must not have
+ *    any use cases associated with it.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, DeleteIntegrationAssociationCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, DeleteIntegrationAssociationCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new DeleteIntegrationAssociationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteIntegrationAssociationCommandInput} for command's `input` shape.
+ * @see {@link DeleteIntegrationAssociationCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteIntegrationAssociationCommand extends $Command<DeleteIntegrationAssociationCommandInput, DeleteIntegrationAssociationCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: DeleteIntegrationAssociationCommandInput;
+    constructor(input: DeleteIntegrationAssociationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteIntegrationAssociationCommandInput, DeleteIntegrationAssociationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

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

@@ -0,0 +1,38 @@
+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 { DeleteUserRequest } from "../models/models_0";
+export interface DeleteUserCommandInput extends DeleteUserRequest {
+}
+export interface DeleteUserCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Deletes a user account from the specified Amazon Connect instance.</p>
+ *          <p>For information about what happens to a user's data when their account is deleted, see
+ *     <a href="https://docs.aws.amazon.com/connect/latest/adminguide/delete-users.html">Delete Users from
+ *     Your Amazon Connect Instance</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, DeleteUserCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, DeleteUserCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new DeleteUserCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteUserCommandInput} for command's `input` shape.
+ * @see {@link DeleteUserCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteUserCommand extends $Command<DeleteUserCommandInput, DeleteUserCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: DeleteUserCommandInput;
+    constructor(input: DeleteUserCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteUserCommandInput, DeleteUserCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteUserHierarchyGroupCommand.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 { DeleteUserHierarchyGroupRequest } from "../models/models_0";
+export interface DeleteUserHierarchyGroupCommandInput extends DeleteUserHierarchyGroupRequest {
+}
+export interface DeleteUserHierarchyGroupCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Deletes an existing user hierarchy group. It must not be associated with any agents or have
+ *    any active child groups.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConnectClient, DeleteUserHierarchyGroupCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, DeleteUserHierarchyGroupCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new DeleteUserHierarchyGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteUserHierarchyGroupCommandInput} for command's `input` shape.
+ * @see {@link DeleteUserHierarchyGroupCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteUserHierarchyGroupCommand extends $Command<DeleteUserHierarchyGroupCommandInput, DeleteUserHierarchyGroupCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: DeleteUserHierarchyGroupCommandInput;
+    constructor(input: DeleteUserHierarchyGroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteUserHierarchyGroupCommandInput, DeleteUserHierarchyGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}