@aws-sdk/client-connect 3.31.0 → 3.35.0

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

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

package/dist-types/commands/ListPhoneNumbersCommand.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 { ListPhoneNumbersRequest, ListPhoneNumbersResponse } from "../models/models_0";
+export interface ListPhoneNumbersCommandInput extends ListPhoneNumbersRequest {
+}
+export interface ListPhoneNumbersCommandOutput extends ListPhoneNumbersResponse, __MetadataBearer {
+}
+/**
+ * <p>Provides information about the phone numbers for the specified Amazon Connect instance. </p>
+ *          <p>For more information about phone numbers, see <a href="https://docs.aws.amazon.com/connect/latest/adminguide/contact-center-phone-number.html">Set Up Phone Numbers for Your
+ *     Contact Center</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, ListPhoneNumbersCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, ListPhoneNumbersCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new ListPhoneNumbersCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListPhoneNumbersCommandInput} for command's `input` shape.
+ * @see {@link ListPhoneNumbersCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListPhoneNumbersCommand extends $Command<ListPhoneNumbersCommandInput, ListPhoneNumbersCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListPhoneNumbersCommandInput;
+    constructor(input: ListPhoneNumbersCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListPhoneNumbersCommandInput, ListPhoneNumbersCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

package/dist-types/commands/ListQueuesCommand.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 { ListQueuesRequest, ListQueuesResponse } from "../models/models_0";
+export interface ListQueuesCommandInput extends ListQueuesRequest {
+}
+export interface ListQueuesCommandOutput extends ListQueuesResponse, __MetadataBearer {
+}
+/**
+ * <p>Provides information about the queues for the specified Amazon Connect instance.</p>
+ *          <p>If you do not specify a <code>QueueTypes</code>
+ *    parameter, both standard and agent queues are returned. This might cause an unexpected truncation
+ *    of results if you have more than 1000 agents and you limit the number of results of the API call
+ *    in code.</p>
+ *          <p>For more information about queues, see <a href="https://docs.aws.amazon.com/connect/latest/adminguide/concepts-queues-standard-and-agent.html">Queues: Standard and
+ *     Agent</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, ListQueuesCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, ListQueuesCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new ListQueuesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListQueuesCommandInput} for command's `input` shape.
+ * @see {@link ListQueuesCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListQueuesCommand extends $Command<ListQueuesCommandInput, ListQueuesCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListQueuesCommandInput;
+    constructor(input: ListQueuesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListQueuesCommandInput, ListQueuesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

package/dist-types/commands/ListRoutingProfilesCommand.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 { ListRoutingProfilesRequest, ListRoutingProfilesResponse } from "../models/models_0";
+export interface ListRoutingProfilesCommandInput extends ListRoutingProfilesRequest {
+}
+export interface ListRoutingProfilesCommandOutput extends ListRoutingProfilesResponse, __MetadataBearer {
+}
+/**
+ * <p>Provides summary information about the routing profiles for the specified Amazon Connect
+ *    instance.</p>
+ *          <p>For more information about routing profiles, see <a href="https://docs.aws.amazon.com/connect/latest/adminguide/concepts-routing.html">Routing Profiles</a> and <a href="https://docs.aws.amazon.com/connect/latest/adminguide/routing-profiles.html">Create a Routing
+ *     Profile</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, ListRoutingProfilesCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, ListRoutingProfilesCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new ListRoutingProfilesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListRoutingProfilesCommandInput} for command's `input` shape.
+ * @see {@link ListRoutingProfilesCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListRoutingProfilesCommand extends $Command<ListRoutingProfilesCommandInput, ListRoutingProfilesCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListRoutingProfilesCommandInput;
+    constructor(input: ListRoutingProfilesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListRoutingProfilesCommandInput, ListRoutingProfilesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

package/dist-types/commands/ListSecurityProfilesCommand.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 { ListSecurityProfilesRequest, ListSecurityProfilesResponse } from "../models/models_0";
+export interface ListSecurityProfilesCommandInput extends ListSecurityProfilesRequest {
+}
+export interface ListSecurityProfilesCommandOutput extends ListSecurityProfilesResponse, __MetadataBearer {
+}
+/**
+ * <p>Provides summary information about the security profiles for the specified Amazon Connect
+ *    instance.</p>
+ *          <p>For more information about security profiles, see <a href="https://docs.aws.amazon.com/connect/latest/adminguide/connect-security-profiles.html">Security Profiles</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, ListSecurityProfilesCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, ListSecurityProfilesCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new ListSecurityProfilesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListSecurityProfilesCommandInput} for command's `input` shape.
+ * @see {@link ListSecurityProfilesCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListSecurityProfilesCommand extends $Command<ListSecurityProfilesCommandInput, ListSecurityProfilesCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListSecurityProfilesCommandInput;
+    constructor(input: ListSecurityProfilesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSecurityProfilesCommandInput, ListSecurityProfilesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

package/dist-types/commands/ListUserHierarchyGroupsCommand.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 { ListUserHierarchyGroupsRequest, ListUserHierarchyGroupsResponse } from "../models/models_0";
+export interface ListUserHierarchyGroupsCommandInput extends ListUserHierarchyGroupsRequest {
+}
+export interface ListUserHierarchyGroupsCommandOutput extends ListUserHierarchyGroupsResponse, __MetadataBearer {
+}
+/**
+ * <p>Provides summary information about the hierarchy groups for the specified Amazon Connect
+ *    instance.</p>
+ *          <p>For more information about agent hierarchies, see <a href="https://docs.aws.amazon.com/connect/latest/adminguide/agent-hierarchy.html">Set Up Agent Hierarchies</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, ListUserHierarchyGroupsCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, ListUserHierarchyGroupsCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new ListUserHierarchyGroupsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListUserHierarchyGroupsCommandInput} for command's `input` shape.
+ * @see {@link ListUserHierarchyGroupsCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListUserHierarchyGroupsCommand extends $Command<ListUserHierarchyGroupsCommandInput, ListUserHierarchyGroupsCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListUserHierarchyGroupsCommandInput;
+    constructor(input: ListUserHierarchyGroupsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListUserHierarchyGroupsCommandInput, ListUserHierarchyGroupsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

package/dist-types/commands/ResumeContactRecordingCommand.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 { ResumeContactRecordingRequest, ResumeContactRecordingResponse } from "../models/models_0";
+export interface ResumeContactRecordingCommandInput extends ResumeContactRecordingRequest {
+}
+export interface ResumeContactRecordingCommandOutput extends ResumeContactRecordingResponse, __MetadataBearer {
+}
+/**
+ * <p>When a contact is being recorded, and the recording has been suspended using
+ *    SuspendContactRecording, this API resumes recording the call.</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, ResumeContactRecordingCommand } from "@aws-sdk/client-connect"; // ES Modules import
+ * // const { ConnectClient, ResumeContactRecordingCommand } = require("@aws-sdk/client-connect"); // CommonJS import
+ * const client = new ConnectClient(config);
+ * const command = new ResumeContactRecordingCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ResumeContactRecordingCommandInput} for command's `input` shape.
+ * @see {@link ResumeContactRecordingCommandOutput} for command's `response` shape.
+ * @see {@link ConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ResumeContactRecordingCommand extends $Command<ResumeContactRecordingCommandInput, ResumeContactRecordingCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ResumeContactRecordingCommandInput;
+    constructor(input: ResumeContactRecordingCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ResumeContactRecordingCommandInput, ResumeContactRecordingCommandOutput>;
+    private serialize;
+    private deserialize;
+}