@aws-sdk/client-connect 3.50.0 → 3.53.0

package/dist-types/ts3.4/commands/DisassociateInstanceStorageConfigCommand.d.ts

@@ -0,0 +1,17 @@
+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 {
+}
+
+export declare class DisassociateInstanceStorageConfigCommand extends $Command<DisassociateInstanceStorageConfigCommandInput, DisassociateInstanceStorageConfigCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: DisassociateInstanceStorageConfigCommandInput;
+    constructor(input: DisassociateInstanceStorageConfigCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateInstanceStorageConfigCommandInput, DisassociateInstanceStorageConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DisassociateLambdaFunctionCommand.d.ts

@@ -0,0 +1,17 @@
+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 {
+}
+
+export declare class DisassociateLambdaFunctionCommand extends $Command<DisassociateLambdaFunctionCommandInput, DisassociateLambdaFunctionCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: DisassociateLambdaFunctionCommandInput;
+    constructor(input: DisassociateLambdaFunctionCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateLambdaFunctionCommandInput, DisassociateLambdaFunctionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DisassociateLexBotCommand.d.ts

@@ -0,0 +1,17 @@
+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 {
+}
+
+export declare class DisassociateLexBotCommand extends $Command<DisassociateLexBotCommandInput, DisassociateLexBotCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: DisassociateLexBotCommandInput;
+    constructor(input: DisassociateLexBotCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateLexBotCommandInput, DisassociateLexBotCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DisassociateQueueQuickConnectsCommand.d.ts

@@ -0,0 +1,17 @@
+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 { DisassociateQueueQuickConnectsRequest } from "../models/models_0";
+export interface DisassociateQueueQuickConnectsCommandInput extends DisassociateQueueQuickConnectsRequest {
+}
+export interface DisassociateQueueQuickConnectsCommandOutput extends __MetadataBearer {
+}
+
+export declare class DisassociateQueueQuickConnectsCommand extends $Command<DisassociateQueueQuickConnectsCommandInput, DisassociateQueueQuickConnectsCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: DisassociateQueueQuickConnectsCommandInput;
+    constructor(input: DisassociateQueueQuickConnectsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateQueueQuickConnectsCommandInput, DisassociateQueueQuickConnectsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DisassociateRoutingProfileQueuesCommand.d.ts

@@ -0,0 +1,17 @@
+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 { DisassociateRoutingProfileQueuesRequest } from "../models/models_0";
+export interface DisassociateRoutingProfileQueuesCommandInput extends DisassociateRoutingProfileQueuesRequest {
+}
+export interface DisassociateRoutingProfileQueuesCommandOutput extends __MetadataBearer {
+}
+
+export declare class DisassociateRoutingProfileQueuesCommand extends $Command<DisassociateRoutingProfileQueuesCommandInput, DisassociateRoutingProfileQueuesCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: DisassociateRoutingProfileQueuesCommandInput;
+    constructor(input: DisassociateRoutingProfileQueuesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateRoutingProfileQueuesCommandInput, DisassociateRoutingProfileQueuesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DisassociateSecurityKeyCommand.d.ts

@@ -0,0 +1,17 @@
+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 { DisassociateSecurityKeyRequest } from "../models/models_0";
+export interface DisassociateSecurityKeyCommandInput extends DisassociateSecurityKeyRequest {
+}
+export interface DisassociateSecurityKeyCommandOutput extends __MetadataBearer {
+}
+
+export declare class DisassociateSecurityKeyCommand extends $Command<DisassociateSecurityKeyCommandInput, DisassociateSecurityKeyCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: DisassociateSecurityKeyCommandInput;
+    constructor(input: DisassociateSecurityKeyCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateSecurityKeyCommandInput, DisassociateSecurityKeyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetContactAttributesCommand.d.ts

@@ -0,0 +1,17 @@
+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 { GetContactAttributesRequest, GetContactAttributesResponse } from "../models/models_0";
+export interface GetContactAttributesCommandInput extends GetContactAttributesRequest {
+}
+export interface GetContactAttributesCommandOutput extends GetContactAttributesResponse, __MetadataBearer {
+}
+
+export declare class GetContactAttributesCommand extends $Command<GetContactAttributesCommandInput, GetContactAttributesCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: GetContactAttributesCommandInput;
+    constructor(input: GetContactAttributesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetContactAttributesCommandInput, GetContactAttributesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetCurrentMetricDataCommand.d.ts

@@ -0,0 +1,17 @@
+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 { GetCurrentMetricDataRequest, GetCurrentMetricDataResponse } from "../models/models_0";
+export interface GetCurrentMetricDataCommandInput extends GetCurrentMetricDataRequest {
+}
+export interface GetCurrentMetricDataCommandOutput extends GetCurrentMetricDataResponse, __MetadataBearer {
+}
+
+export declare class GetCurrentMetricDataCommand extends $Command<GetCurrentMetricDataCommandInput, GetCurrentMetricDataCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: GetCurrentMetricDataCommandInput;
+    constructor(input: GetCurrentMetricDataCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCurrentMetricDataCommandInput, GetCurrentMetricDataCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetFederationTokenCommand.d.ts

@@ -0,0 +1,17 @@
+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 { GetFederationTokenRequest, GetFederationTokenResponse } from "../models/models_0";
+export interface GetFederationTokenCommandInput extends GetFederationTokenRequest {
+}
+export interface GetFederationTokenCommandOutput extends GetFederationTokenResponse, __MetadataBearer {
+}
+
+export declare class GetFederationTokenCommand extends $Command<GetFederationTokenCommandInput, GetFederationTokenCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: GetFederationTokenCommandInput;
+    constructor(input: GetFederationTokenCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFederationTokenCommandInput, GetFederationTokenCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetMetricDataCommand.d.ts

@@ -0,0 +1,17 @@
+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 { GetMetricDataRequest, GetMetricDataResponse } from "../models/models_0";
+export interface GetMetricDataCommandInput extends GetMetricDataRequest {
+}
+export interface GetMetricDataCommandOutput extends GetMetricDataResponse, __MetadataBearer {
+}
+
+export declare class GetMetricDataCommand extends $Command<GetMetricDataCommandInput, GetMetricDataCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: GetMetricDataCommandInput;
+    constructor(input: GetMetricDataCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetMetricDataCommandInput, GetMetricDataCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListAgentStatusesCommand.d.ts

@@ -0,0 +1,17 @@
+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 { ListAgentStatusRequest, ListAgentStatusResponse } from "../models/models_0";
+export interface ListAgentStatusesCommandInput extends ListAgentStatusRequest {
+}
+export interface ListAgentStatusesCommandOutput extends ListAgentStatusResponse, __MetadataBearer {
+}
+
+export declare class ListAgentStatusesCommand extends $Command<ListAgentStatusesCommandInput, ListAgentStatusesCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListAgentStatusesCommandInput;
+    constructor(input: ListAgentStatusesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListAgentStatusesCommandInput, ListAgentStatusesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListApprovedOriginsCommand.d.ts

@@ -0,0 +1,17 @@
+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 { ListApprovedOriginsRequest, ListApprovedOriginsResponse } from "../models/models_0";
+export interface ListApprovedOriginsCommandInput extends ListApprovedOriginsRequest {
+}
+export interface ListApprovedOriginsCommandOutput extends ListApprovedOriginsResponse, __MetadataBearer {
+}
+
+export declare class ListApprovedOriginsCommand extends $Command<ListApprovedOriginsCommandInput, ListApprovedOriginsCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListApprovedOriginsCommandInput;
+    constructor(input: ListApprovedOriginsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListApprovedOriginsCommandInput, ListApprovedOriginsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListBotsCommand.d.ts

@@ -0,0 +1,17 @@
+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 { ListBotsRequest, ListBotsResponse } from "../models/models_0";
+export interface ListBotsCommandInput extends ListBotsRequest {
+}
+export interface ListBotsCommandOutput extends ListBotsResponse, __MetadataBearer {
+}
+
+export declare class ListBotsCommand extends $Command<ListBotsCommandInput, ListBotsCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListBotsCommandInput;
+    constructor(input: ListBotsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListBotsCommandInput, ListBotsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListContactFlowModulesCommand.d.ts

@@ -0,0 +1,17 @@
+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 { ListContactFlowModulesRequest, ListContactFlowModulesResponse } from "../models/models_0";
+export interface ListContactFlowModulesCommandInput extends ListContactFlowModulesRequest {
+}
+export interface ListContactFlowModulesCommandOutput extends ListContactFlowModulesResponse, __MetadataBearer {
+}
+
+export declare class ListContactFlowModulesCommand extends $Command<ListContactFlowModulesCommandInput, ListContactFlowModulesCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListContactFlowModulesCommandInput;
+    constructor(input: ListContactFlowModulesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListContactFlowModulesCommandInput, ListContactFlowModulesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListContactFlowsCommand.d.ts

@@ -0,0 +1,17 @@
+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 { ListContactFlowsRequest, ListContactFlowsResponse } from "../models/models_0";
+export interface ListContactFlowsCommandInput extends ListContactFlowsRequest {
+}
+export interface ListContactFlowsCommandOutput extends ListContactFlowsResponse, __MetadataBearer {
+}
+
+export declare class ListContactFlowsCommand extends $Command<ListContactFlowsCommandInput, ListContactFlowsCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListContactFlowsCommandInput;
+    constructor(input: ListContactFlowsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListContactFlowsCommandInput, ListContactFlowsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListContactReferencesCommand.d.ts

@@ -0,0 +1,17 @@
+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 { ListContactReferencesRequest, ListContactReferencesResponse } from "../models/models_0";
+export interface ListContactReferencesCommandInput extends ListContactReferencesRequest {
+}
+export interface ListContactReferencesCommandOutput extends ListContactReferencesResponse, __MetadataBearer {
+}
+
+export declare class ListContactReferencesCommand extends $Command<ListContactReferencesCommandInput, ListContactReferencesCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListContactReferencesCommandInput;
+    constructor(input: ListContactReferencesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListContactReferencesCommandInput, ListContactReferencesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListDefaultVocabulariesCommand.d.ts

@@ -0,0 +1,17 @@
+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 { ListDefaultVocabulariesRequest, ListDefaultVocabulariesResponse } from "../models/models_0";
+export interface ListDefaultVocabulariesCommandInput extends ListDefaultVocabulariesRequest {
+}
+export interface ListDefaultVocabulariesCommandOutput extends ListDefaultVocabulariesResponse, __MetadataBearer {
+}
+
+export declare class ListDefaultVocabulariesCommand extends $Command<ListDefaultVocabulariesCommandInput, ListDefaultVocabulariesCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListDefaultVocabulariesCommandInput;
+    constructor(input: ListDefaultVocabulariesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDefaultVocabulariesCommandInput, ListDefaultVocabulariesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListHoursOfOperationsCommand.d.ts

@@ -0,0 +1,17 @@
+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 { ListHoursOfOperationsRequest, ListHoursOfOperationsResponse } from "../models/models_0";
+export interface ListHoursOfOperationsCommandInput extends ListHoursOfOperationsRequest {
+}
+export interface ListHoursOfOperationsCommandOutput extends ListHoursOfOperationsResponse, __MetadataBearer {
+}
+
+export declare class ListHoursOfOperationsCommand extends $Command<ListHoursOfOperationsCommandInput, ListHoursOfOperationsCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListHoursOfOperationsCommandInput;
+    constructor(input: ListHoursOfOperationsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListHoursOfOperationsCommandInput, ListHoursOfOperationsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListInstanceAttributesCommand.d.ts

@@ -0,0 +1,17 @@
+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 { ListInstanceAttributesRequest, ListInstanceAttributesResponse } from "../models/models_0";
+export interface ListInstanceAttributesCommandInput extends ListInstanceAttributesRequest {
+}
+export interface ListInstanceAttributesCommandOutput extends ListInstanceAttributesResponse, __MetadataBearer {
+}
+
+export declare class ListInstanceAttributesCommand extends $Command<ListInstanceAttributesCommandInput, ListInstanceAttributesCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListInstanceAttributesCommandInput;
+    constructor(input: ListInstanceAttributesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListInstanceAttributesCommandInput, ListInstanceAttributesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListInstanceStorageConfigsCommand.d.ts

@@ -0,0 +1,17 @@
+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 { ListInstanceStorageConfigsRequest, ListInstanceStorageConfigsResponse } from "../models/models_0";
+export interface ListInstanceStorageConfigsCommandInput extends ListInstanceStorageConfigsRequest {
+}
+export interface ListInstanceStorageConfigsCommandOutput extends ListInstanceStorageConfigsResponse, __MetadataBearer {
+}
+
+export declare class ListInstanceStorageConfigsCommand extends $Command<ListInstanceStorageConfigsCommandInput, ListInstanceStorageConfigsCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListInstanceStorageConfigsCommandInput;
+    constructor(input: ListInstanceStorageConfigsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListInstanceStorageConfigsCommandInput, ListInstanceStorageConfigsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListInstancesCommand.d.ts

@@ -0,0 +1,17 @@
+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 { ListInstancesRequest, ListInstancesResponse } from "../models/models_0";
+export interface ListInstancesCommandInput extends ListInstancesRequest {
+}
+export interface ListInstancesCommandOutput extends ListInstancesResponse, __MetadataBearer {
+}
+
+export declare class ListInstancesCommand extends $Command<ListInstancesCommandInput, ListInstancesCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListInstancesCommandInput;
+    constructor(input: ListInstancesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListInstancesCommandInput, ListInstancesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListIntegrationAssociationsCommand.d.ts

@@ -0,0 +1,17 @@
+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 { ListIntegrationAssociationsRequest, ListIntegrationAssociationsResponse } from "../models/models_0";
+export interface ListIntegrationAssociationsCommandInput extends ListIntegrationAssociationsRequest {
+}
+export interface ListIntegrationAssociationsCommandOutput extends ListIntegrationAssociationsResponse, __MetadataBearer {
+}
+
+export declare class ListIntegrationAssociationsCommand extends $Command<ListIntegrationAssociationsCommandInput, ListIntegrationAssociationsCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListIntegrationAssociationsCommandInput;
+    constructor(input: ListIntegrationAssociationsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListIntegrationAssociationsCommandInput, ListIntegrationAssociationsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListLambdaFunctionsCommand.d.ts

@@ -0,0 +1,17 @@
+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 {
+}
+
+export declare class ListLambdaFunctionsCommand extends $Command<ListLambdaFunctionsCommandInput, ListLambdaFunctionsCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListLambdaFunctionsCommandInput;
+    constructor(input: ListLambdaFunctionsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListLambdaFunctionsCommandInput, ListLambdaFunctionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListLexBotsCommand.d.ts

@@ -0,0 +1,17 @@
+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 {
+}
+
+export declare class ListLexBotsCommand extends $Command<ListLexBotsCommandInput, ListLexBotsCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListLexBotsCommandInput;
+    constructor(input: ListLexBotsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListLexBotsCommandInput, ListLexBotsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListPhoneNumbersCommand.d.ts

@@ -0,0 +1,17 @@
+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 {
+}
+
+export declare class ListPhoneNumbersCommand extends $Command<ListPhoneNumbersCommandInput, ListPhoneNumbersCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListPhoneNumbersCommandInput;
+    constructor(input: ListPhoneNumbersCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListPhoneNumbersCommandInput, ListPhoneNumbersCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListPromptsCommand.d.ts

@@ -0,0 +1,17 @@
+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 {
+}
+
+export declare class ListPromptsCommand extends $Command<ListPromptsCommandInput, ListPromptsCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListPromptsCommandInput;
+    constructor(input: ListPromptsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListPromptsCommandInput, ListPromptsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListQueueQuickConnectsCommand.d.ts

@@ -0,0 +1,17 @@
+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 {
+}
+
+export declare class ListQueueQuickConnectsCommand extends $Command<ListQueueQuickConnectsCommandInput, ListQueueQuickConnectsCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListQueueQuickConnectsCommandInput;
+    constructor(input: ListQueueQuickConnectsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListQueueQuickConnectsCommandInput, ListQueueQuickConnectsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListQueuesCommand.d.ts

@@ -0,0 +1,17 @@
+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 {
+}
+
+export declare class ListQueuesCommand extends $Command<ListQueuesCommandInput, ListQueuesCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListQueuesCommandInput;
+    constructor(input: ListQueuesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListQueuesCommandInput, ListQueuesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListQuickConnectsCommand.d.ts

@@ -0,0 +1,17 @@
+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 {
+}
+
+export declare class ListQuickConnectsCommand extends $Command<ListQuickConnectsCommandInput, ListQuickConnectsCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListQuickConnectsCommandInput;
+    constructor(input: ListQuickConnectsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListQuickConnectsCommandInput, ListQuickConnectsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListRoutingProfileQueuesCommand.d.ts

@@ -0,0 +1,17 @@
+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 {
+}
+
+export declare class ListRoutingProfileQueuesCommand extends $Command<ListRoutingProfileQueuesCommandInput, ListRoutingProfileQueuesCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListRoutingProfileQueuesCommandInput;
+    constructor(input: ListRoutingProfileQueuesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListRoutingProfileQueuesCommandInput, ListRoutingProfileQueuesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListRoutingProfilesCommand.d.ts

@@ -0,0 +1,17 @@
+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 {
+}
+
+export declare class ListRoutingProfilesCommand extends $Command<ListRoutingProfilesCommandInput, ListRoutingProfilesCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListRoutingProfilesCommandInput;
+    constructor(input: ListRoutingProfilesCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListRoutingProfilesCommandInput, ListRoutingProfilesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListSecurityKeysCommand.d.ts

@@ -0,0 +1,17 @@
+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 {
+}
+
+export declare class ListSecurityKeysCommand extends $Command<ListSecurityKeysCommandInput, ListSecurityKeysCommandOutput, ConnectClientResolvedConfig> {
+    readonly input: ListSecurityKeysCommandInput;
+    constructor(input: ListSecurityKeysCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSecurityKeysCommandInput, ListSecurityKeysCommandOutput>;
+    private serialize;
+    private deserialize;
+}