@aws-sdk/client-connect 3.34.0 → 3.37.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,3598 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+export declare enum AgentStatusState {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export declare enum AgentStatusType {
+    CUSTOM = "CUSTOM",
+    OFFLINE = "OFFLINE",
+    ROUTABLE = "ROUTABLE"
+}
+
+export interface AgentStatus {
+    
+    AgentStatusARN?: string;
+    
+    AgentStatusId?: string;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    Type?: AgentStatusType | string;
+    
+    DisplayOrder?: number;
+    
+    State?: AgentStatusState | string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace AgentStatus {
+    
+    const filterSensitiveLog: (obj: AgentStatus) => any;
+}
+
+export interface AgentStatusSummary {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Name?: string;
+    
+    Type?: AgentStatusType | string;
+}
+export declare namespace AgentStatusSummary {
+    
+    const filterSensitiveLog: (obj: AgentStatusSummary) => any;
+}
+export interface AssociateApprovedOriginRequest {
+    
+    InstanceId: string | undefined;
+    
+    Origin: string | undefined;
+}
+export declare namespace AssociateApprovedOriginRequest {
+    
+    const filterSensitiveLog: (obj: AssociateApprovedOriginRequest) => any;
+}
+
+export interface InternalServiceException extends __SmithyException, $MetadataBearer {
+    name: "InternalServiceException";
+    $fault: "server";
+    
+    Message?: string;
+}
+export declare namespace InternalServiceException {
+    
+    const filterSensitiveLog: (obj: InternalServiceException) => any;
+}
+
+export interface InvalidParameterException extends __SmithyException, $MetadataBearer {
+    name: "InvalidParameterException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidParameterException {
+    
+    const filterSensitiveLog: (obj: InvalidParameterException) => any;
+}
+
+export interface InvalidRequestException extends __SmithyException, $MetadataBearer {
+    name: "InvalidRequestException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidRequestException {
+    
+    const filterSensitiveLog: (obj: InvalidRequestException) => any;
+}
+
+export interface ResourceConflictException extends __SmithyException, $MetadataBearer {
+    name: "ResourceConflictException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace ResourceConflictException {
+    
+    const filterSensitiveLog: (obj: ResourceConflictException) => any;
+}
+
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace ResourceNotFoundException {
+    
+    const filterSensitiveLog: (obj: ResourceNotFoundException) => any;
+}
+
+export interface ServiceQuotaExceededException extends __SmithyException, $MetadataBearer {
+    name: "ServiceQuotaExceededException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace ServiceQuotaExceededException {
+    
+    const filterSensitiveLog: (obj: ServiceQuotaExceededException) => any;
+}
+
+export interface ThrottlingException extends __SmithyException, $MetadataBearer {
+    name: "ThrottlingException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace ThrottlingException {
+    
+    const filterSensitiveLog: (obj: ThrottlingException) => any;
+}
+
+export interface LexBot {
+    
+    Name?: string;
+    
+    LexRegion?: string;
+}
+export declare namespace LexBot {
+    
+    const filterSensitiveLog: (obj: LexBot) => any;
+}
+
+export interface LexV2Bot {
+    
+    AliasArn?: string;
+}
+export declare namespace LexV2Bot {
+    
+    const filterSensitiveLog: (obj: LexV2Bot) => any;
+}
+export interface AssociateBotRequest {
+    
+    InstanceId: string | undefined;
+    
+    LexBot?: LexBot;
+    
+    LexV2Bot?: LexV2Bot;
+}
+export declare namespace AssociateBotRequest {
+    
+    const filterSensitiveLog: (obj: AssociateBotRequest) => any;
+}
+
+export interface LimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "LimitExceededException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace LimitExceededException {
+    
+    const filterSensitiveLog: (obj: LimitExceededException) => any;
+}
+export declare enum InstanceStorageResourceType {
+    AGENT_EVENTS = "AGENT_EVENTS",
+    CALL_RECORDINGS = "CALL_RECORDINGS",
+    CHAT_TRANSCRIPTS = "CHAT_TRANSCRIPTS",
+    CONTACT_TRACE_RECORDS = "CONTACT_TRACE_RECORDS",
+    MEDIA_STREAMS = "MEDIA_STREAMS",
+    SCHEDULED_REPORTS = "SCHEDULED_REPORTS"
+}
+
+export interface KinesisFirehoseConfig {
+    
+    FirehoseArn: string | undefined;
+}
+export declare namespace KinesisFirehoseConfig {
+    
+    const filterSensitiveLog: (obj: KinesisFirehoseConfig) => any;
+}
+
+export interface KinesisStreamConfig {
+    
+    StreamArn: string | undefined;
+}
+export declare namespace KinesisStreamConfig {
+    
+    const filterSensitiveLog: (obj: KinesisStreamConfig) => any;
+}
+export declare enum EncryptionType {
+    KMS = "KMS"
+}
+
+export interface EncryptionConfig {
+    
+    EncryptionType: EncryptionType | string | undefined;
+    
+    KeyId: string | undefined;
+}
+export declare namespace EncryptionConfig {
+    
+    const filterSensitiveLog: (obj: EncryptionConfig) => any;
+}
+
+export interface KinesisVideoStreamConfig {
+    
+    Prefix: string | undefined;
+    
+    RetentionPeriodHours: number | undefined;
+    
+    EncryptionConfig: EncryptionConfig | undefined;
+}
+export declare namespace KinesisVideoStreamConfig {
+    
+    const filterSensitiveLog: (obj: KinesisVideoStreamConfig) => any;
+}
+
+export interface S3Config {
+    
+    BucketName: string | undefined;
+    
+    BucketPrefix: string | undefined;
+    
+    EncryptionConfig?: EncryptionConfig;
+}
+export declare namespace S3Config {
+    
+    const filterSensitiveLog: (obj: S3Config) => any;
+}
+export declare enum StorageType {
+    KINESIS_FIREHOSE = "KINESIS_FIREHOSE",
+    KINESIS_STREAM = "KINESIS_STREAM",
+    KINESIS_VIDEO_STREAM = "KINESIS_VIDEO_STREAM",
+    S3 = "S3"
+}
+
+export interface InstanceStorageConfig {
+    
+    AssociationId?: string;
+    
+    StorageType: StorageType | string | undefined;
+    
+    S3Config?: S3Config;
+    
+    KinesisVideoStreamConfig?: KinesisVideoStreamConfig;
+    
+    KinesisStreamConfig?: KinesisStreamConfig;
+    
+    KinesisFirehoseConfig?: KinesisFirehoseConfig;
+}
+export declare namespace InstanceStorageConfig {
+    
+    const filterSensitiveLog: (obj: InstanceStorageConfig) => any;
+}
+export interface AssociateInstanceStorageConfigRequest {
+    
+    InstanceId: string | undefined;
+    
+    ResourceType: InstanceStorageResourceType | string | undefined;
+    
+    StorageConfig: InstanceStorageConfig | undefined;
+}
+export declare namespace AssociateInstanceStorageConfigRequest {
+    
+    const filterSensitiveLog: (obj: AssociateInstanceStorageConfigRequest) => any;
+}
+export interface AssociateInstanceStorageConfigResponse {
+    
+    AssociationId?: string;
+}
+export declare namespace AssociateInstanceStorageConfigResponse {
+    
+    const filterSensitiveLog: (obj: AssociateInstanceStorageConfigResponse) => any;
+}
+export interface AssociateLambdaFunctionRequest {
+    
+    InstanceId: string | undefined;
+    
+    FunctionArn: string | undefined;
+}
+export declare namespace AssociateLambdaFunctionRequest {
+    
+    const filterSensitiveLog: (obj: AssociateLambdaFunctionRequest) => any;
+}
+export interface AssociateLexBotRequest {
+    
+    InstanceId: string | undefined;
+    
+    LexBot: LexBot | undefined;
+}
+export declare namespace AssociateLexBotRequest {
+    
+    const filterSensitiveLog: (obj: AssociateLexBotRequest) => any;
+}
+export interface AssociateQueueQuickConnectsRequest {
+    
+    InstanceId: string | undefined;
+    
+    QueueId: string | undefined;
+    
+    QuickConnectIds: string[] | undefined;
+}
+export declare namespace AssociateQueueQuickConnectsRequest {
+    
+    const filterSensitiveLog: (obj: AssociateQueueQuickConnectsRequest) => any;
+}
+export declare enum Channel {
+    CHAT = "CHAT",
+    TASK = "TASK",
+    VOICE = "VOICE"
+}
+
+export interface RoutingProfileQueueReference {
+    
+    QueueId: string | undefined;
+    
+    Channel: Channel | string | undefined;
+}
+export declare namespace RoutingProfileQueueReference {
+    
+    const filterSensitiveLog: (obj: RoutingProfileQueueReference) => any;
+}
+
+export interface RoutingProfileQueueConfig {
+    
+    QueueReference: RoutingProfileQueueReference | undefined;
+    
+    Priority: number | undefined;
+    
+    Delay: number | undefined;
+}
+export declare namespace RoutingProfileQueueConfig {
+    
+    const filterSensitiveLog: (obj: RoutingProfileQueueConfig) => any;
+}
+export interface AssociateRoutingProfileQueuesRequest {
+    
+    InstanceId: string | undefined;
+    
+    RoutingProfileId: string | undefined;
+    
+    QueueConfigs: RoutingProfileQueueConfig[] | undefined;
+}
+export declare namespace AssociateRoutingProfileQueuesRequest {
+    
+    const filterSensitiveLog: (obj: AssociateRoutingProfileQueuesRequest) => any;
+}
+export interface AssociateSecurityKeyRequest {
+    
+    InstanceId: string | undefined;
+    
+    Key: string | undefined;
+}
+export declare namespace AssociateSecurityKeyRequest {
+    
+    const filterSensitiveLog: (obj: AssociateSecurityKeyRequest) => any;
+}
+export interface AssociateSecurityKeyResponse {
+    
+    AssociationId?: string;
+}
+export declare namespace AssociateSecurityKeyResponse {
+    
+    const filterSensitiveLog: (obj: AssociateSecurityKeyResponse) => any;
+}
+export interface CreateAgentStatusRequest {
+    
+    InstanceId: string | undefined;
+    
+    Name: string | undefined;
+    
+    Description?: string;
+    
+    State: AgentStatusState | string | undefined;
+    
+    DisplayOrder?: number;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateAgentStatusRequest {
+    
+    const filterSensitiveLog: (obj: CreateAgentStatusRequest) => any;
+}
+export interface CreateAgentStatusResponse {
+    
+    AgentStatusARN?: string;
+    
+    AgentStatusId?: string;
+}
+export declare namespace CreateAgentStatusResponse {
+    
+    const filterSensitiveLog: (obj: CreateAgentStatusResponse) => any;
+}
+
+export interface DuplicateResourceException extends __SmithyException, $MetadataBearer {
+    name: "DuplicateResourceException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace DuplicateResourceException {
+    
+    const filterSensitiveLog: (obj: DuplicateResourceException) => any;
+}
+export declare enum ContactFlowType {
+    AGENT_HOLD = "AGENT_HOLD",
+    AGENT_TRANSFER = "AGENT_TRANSFER",
+    AGENT_WHISPER = "AGENT_WHISPER",
+    CONTACT_FLOW = "CONTACT_FLOW",
+    CUSTOMER_HOLD = "CUSTOMER_HOLD",
+    CUSTOMER_QUEUE = "CUSTOMER_QUEUE",
+    CUSTOMER_WHISPER = "CUSTOMER_WHISPER",
+    OUTBOUND_WHISPER = "OUTBOUND_WHISPER",
+    QUEUE_TRANSFER = "QUEUE_TRANSFER"
+}
+export interface CreateContactFlowRequest {
+    
+    InstanceId: string | undefined;
+    
+    Name: string | undefined;
+    
+    Type: ContactFlowType | string | undefined;
+    
+    Description?: string;
+    
+    Content: string | undefined;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateContactFlowRequest {
+    
+    const filterSensitiveLog: (obj: CreateContactFlowRequest) => any;
+}
+export interface CreateContactFlowResponse {
+    
+    ContactFlowId?: string;
+    
+    ContactFlowArn?: string;
+}
+export declare namespace CreateContactFlowResponse {
+    
+    const filterSensitiveLog: (obj: CreateContactFlowResponse) => any;
+}
+
+export interface ProblemDetail {
+    
+    message?: string;
+}
+export declare namespace ProblemDetail {
+    
+    const filterSensitiveLog: (obj: ProblemDetail) => any;
+}
+
+export interface InvalidContactFlowException extends __SmithyException, $MetadataBearer {
+    name: "InvalidContactFlowException";
+    $fault: "client";
+    
+    problems?: ProblemDetail[];
+}
+export declare namespace InvalidContactFlowException {
+    
+    const filterSensitiveLog: (obj: InvalidContactFlowException) => any;
+}
+export declare enum HoursOfOperationDays {
+    FRIDAY = "FRIDAY",
+    MONDAY = "MONDAY",
+    SATURDAY = "SATURDAY",
+    SUNDAY = "SUNDAY",
+    THURSDAY = "THURSDAY",
+    TUESDAY = "TUESDAY",
+    WEDNESDAY = "WEDNESDAY"
+}
+
+export interface HoursOfOperationTimeSlice {
+    
+    Hours: number | undefined;
+    
+    Minutes: number | undefined;
+}
+export declare namespace HoursOfOperationTimeSlice {
+    
+    const filterSensitiveLog: (obj: HoursOfOperationTimeSlice) => any;
+}
+
+export interface HoursOfOperationConfig {
+    
+    Day: HoursOfOperationDays | string | undefined;
+    
+    StartTime: HoursOfOperationTimeSlice | undefined;
+    
+    EndTime: HoursOfOperationTimeSlice | undefined;
+}
+export declare namespace HoursOfOperationConfig {
+    
+    const filterSensitiveLog: (obj: HoursOfOperationConfig) => any;
+}
+export interface CreateHoursOfOperationRequest {
+    
+    InstanceId: string | undefined;
+    
+    Name: string | undefined;
+    
+    Description?: string;
+    
+    TimeZone: string | undefined;
+    
+    Config: HoursOfOperationConfig[] | undefined;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateHoursOfOperationRequest {
+    
+    const filterSensitiveLog: (obj: CreateHoursOfOperationRequest) => any;
+}
+export interface CreateHoursOfOperationResponse {
+    
+    HoursOfOperationId?: string;
+    
+    HoursOfOperationArn?: string;
+}
+export declare namespace CreateHoursOfOperationResponse {
+    
+    const filterSensitiveLog: (obj: CreateHoursOfOperationResponse) => any;
+}
+export declare enum DirectoryType {
+    CONNECT_MANAGED = "CONNECT_MANAGED",
+    EXISTING_DIRECTORY = "EXISTING_DIRECTORY",
+    SAML = "SAML"
+}
+export interface CreateInstanceRequest {
+    
+    ClientToken?: string;
+    
+    IdentityManagementType: DirectoryType | string | undefined;
+    
+    InstanceAlias?: string;
+    
+    DirectoryId?: string;
+    
+    InboundCallsEnabled: boolean | undefined;
+    
+    OutboundCallsEnabled: boolean | undefined;
+}
+export declare namespace CreateInstanceRequest {
+    
+    const filterSensitiveLog: (obj: CreateInstanceRequest) => any;
+}
+export interface CreateInstanceResponse {
+    
+    Id?: string;
+    
+    Arn?: string;
+}
+export declare namespace CreateInstanceResponse {
+    
+    const filterSensitiveLog: (obj: CreateInstanceResponse) => any;
+}
+export declare enum IntegrationType {
+    EVENT = "EVENT",
+    PINPOINT_APP = "PINPOINT_APP",
+    VOICE_ID = "VOICE_ID",
+    WISDOM_ASSISTANT = "WISDOM_ASSISTANT",
+    WISDOM_KNOWLEDGE_BASE = "WISDOM_KNOWLEDGE_BASE"
+}
+export declare enum SourceType {
+    SALESFORCE = "SALESFORCE",
+    ZENDESK = "ZENDESK"
+}
+export interface CreateIntegrationAssociationRequest {
+    
+    InstanceId: string | undefined;
+    
+    IntegrationType: IntegrationType | string | undefined;
+    
+    IntegrationArn: string | undefined;
+    
+    SourceApplicationUrl?: string;
+    
+    SourceApplicationName?: string;
+    
+    SourceType?: SourceType | string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateIntegrationAssociationRequest {
+    
+    const filterSensitiveLog: (obj: CreateIntegrationAssociationRequest) => any;
+}
+export interface CreateIntegrationAssociationResponse {
+    
+    IntegrationAssociationId?: string;
+    
+    IntegrationAssociationArn?: string;
+}
+export declare namespace CreateIntegrationAssociationResponse {
+    
+    const filterSensitiveLog: (obj: CreateIntegrationAssociationResponse) => any;
+}
+
+export interface OutboundCallerConfig {
+    
+    OutboundCallerIdName?: string;
+    
+    OutboundCallerIdNumberId?: string;
+    
+    OutboundFlowId?: string;
+}
+export declare namespace OutboundCallerConfig {
+    
+    const filterSensitiveLog: (obj: OutboundCallerConfig) => any;
+}
+export interface CreateQueueRequest {
+    
+    InstanceId: string | undefined;
+    
+    Name: string | undefined;
+    
+    Description?: string;
+    
+    OutboundCallerConfig?: OutboundCallerConfig;
+    
+    HoursOfOperationId: string | undefined;
+    
+    MaxContacts?: number;
+    
+    QuickConnectIds?: string[];
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateQueueRequest {
+    
+    const filterSensitiveLog: (obj: CreateQueueRequest) => any;
+}
+export interface CreateQueueResponse {
+    
+    QueueArn?: string;
+    
+    QueueId?: string;
+}
+export declare namespace CreateQueueResponse {
+    
+    const filterSensitiveLog: (obj: CreateQueueResponse) => any;
+}
+
+export interface PhoneNumberQuickConnectConfig {
+    
+    PhoneNumber: string | undefined;
+}
+export declare namespace PhoneNumberQuickConnectConfig {
+    
+    const filterSensitiveLog: (obj: PhoneNumberQuickConnectConfig) => any;
+}
+
+export interface QueueQuickConnectConfig {
+    
+    QueueId: string | undefined;
+    
+    ContactFlowId: string | undefined;
+}
+export declare namespace QueueQuickConnectConfig {
+    
+    const filterSensitiveLog: (obj: QueueQuickConnectConfig) => any;
+}
+export declare enum QuickConnectType {
+    PHONE_NUMBER = "PHONE_NUMBER",
+    QUEUE = "QUEUE",
+    USER = "USER"
+}
+
+export interface UserQuickConnectConfig {
+    
+    UserId: string | undefined;
+    
+    ContactFlowId: string | undefined;
+}
+export declare namespace UserQuickConnectConfig {
+    
+    const filterSensitiveLog: (obj: UserQuickConnectConfig) => any;
+}
+
+export interface QuickConnectConfig {
+    
+    QuickConnectType: QuickConnectType | string | undefined;
+    
+    UserConfig?: UserQuickConnectConfig;
+    
+    QueueConfig?: QueueQuickConnectConfig;
+    
+    PhoneConfig?: PhoneNumberQuickConnectConfig;
+}
+export declare namespace QuickConnectConfig {
+    
+    const filterSensitiveLog: (obj: QuickConnectConfig) => any;
+}
+export interface CreateQuickConnectRequest {
+    
+    InstanceId: string | undefined;
+    
+    Name: string | undefined;
+    
+    Description?: string;
+    
+    QuickConnectConfig: QuickConnectConfig | undefined;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateQuickConnectRequest {
+    
+    const filterSensitiveLog: (obj: CreateQuickConnectRequest) => any;
+}
+export interface CreateQuickConnectResponse {
+    
+    QuickConnectARN?: string;
+    
+    QuickConnectId?: string;
+}
+export declare namespace CreateQuickConnectResponse {
+    
+    const filterSensitiveLog: (obj: CreateQuickConnectResponse) => any;
+}
+
+export interface MediaConcurrency {
+    
+    Channel: Channel | string | undefined;
+    
+    Concurrency: number | undefined;
+}
+export declare namespace MediaConcurrency {
+    
+    const filterSensitiveLog: (obj: MediaConcurrency) => any;
+}
+export interface CreateRoutingProfileRequest {
+    
+    InstanceId: string | undefined;
+    
+    Name: string | undefined;
+    
+    Description: string | undefined;
+    
+    DefaultOutboundQueueId: string | undefined;
+    
+    QueueConfigs?: RoutingProfileQueueConfig[];
+    
+    MediaConcurrencies: MediaConcurrency[] | undefined;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateRoutingProfileRequest {
+    
+    const filterSensitiveLog: (obj: CreateRoutingProfileRequest) => any;
+}
+export interface CreateRoutingProfileResponse {
+    
+    RoutingProfileArn?: string;
+    
+    RoutingProfileId?: string;
+}
+export declare namespace CreateRoutingProfileResponse {
+    
+    const filterSensitiveLog: (obj: CreateRoutingProfileResponse) => any;
+}
+export declare enum UseCaseType {
+    CONNECT_CAMPAIGNS = "CONNECT_CAMPAIGNS",
+    RULES_EVALUATION = "RULES_EVALUATION"
+}
+export interface CreateUseCaseRequest {
+    
+    InstanceId: string | undefined;
+    
+    IntegrationAssociationId: string | undefined;
+    
+    UseCaseType: UseCaseType | string | undefined;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateUseCaseRequest {
+    
+    const filterSensitiveLog: (obj: CreateUseCaseRequest) => any;
+}
+export interface CreateUseCaseResponse {
+    
+    UseCaseId?: string;
+    
+    UseCaseArn?: string;
+}
+export declare namespace CreateUseCaseResponse {
+    
+    const filterSensitiveLog: (obj: CreateUseCaseResponse) => any;
+}
+
+export interface UserIdentityInfo {
+    
+    FirstName?: string;
+    
+    LastName?: string;
+    
+    Email?: string;
+}
+export declare namespace UserIdentityInfo {
+    
+    const filterSensitiveLog: (obj: UserIdentityInfo) => any;
+}
+export declare enum PhoneType {
+    DESK_PHONE = "DESK_PHONE",
+    SOFT_PHONE = "SOFT_PHONE"
+}
+
+export interface UserPhoneConfig {
+    
+    PhoneType: PhoneType | string | undefined;
+    
+    AutoAccept?: boolean;
+    
+    AfterContactWorkTimeLimit?: number;
+    
+    DeskPhoneNumber?: string;
+}
+export declare namespace UserPhoneConfig {
+    
+    const filterSensitiveLog: (obj: UserPhoneConfig) => any;
+}
+export interface CreateUserRequest {
+    
+    Username: string | undefined;
+    
+    Password?: string;
+    
+    IdentityInfo?: UserIdentityInfo;
+    
+    PhoneConfig: UserPhoneConfig | undefined;
+    
+    DirectoryUserId?: string;
+    
+    SecurityProfileIds: string[] | undefined;
+    
+    RoutingProfileId: string | undefined;
+    
+    HierarchyGroupId?: string;
+    
+    InstanceId: string | undefined;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateUserRequest {
+    
+    const filterSensitiveLog: (obj: CreateUserRequest) => any;
+}
+export interface CreateUserResponse {
+    
+    UserId?: string;
+    
+    UserArn?: string;
+}
+export declare namespace CreateUserResponse {
+    
+    const filterSensitiveLog: (obj: CreateUserResponse) => any;
+}
+export interface CreateUserHierarchyGroupRequest {
+    
+    Name: string | undefined;
+    
+    ParentGroupId?: string;
+    
+    InstanceId: string | undefined;
+}
+export declare namespace CreateUserHierarchyGroupRequest {
+    
+    const filterSensitiveLog: (obj: CreateUserHierarchyGroupRequest) => any;
+}
+export interface CreateUserHierarchyGroupResponse {
+    
+    HierarchyGroupId?: string;
+    
+    HierarchyGroupArn?: string;
+}
+export declare namespace CreateUserHierarchyGroupResponse {
+    
+    const filterSensitiveLog: (obj: CreateUserHierarchyGroupResponse) => any;
+}
+export interface DeleteHoursOfOperationRequest {
+    
+    InstanceId: string | undefined;
+    
+    HoursOfOperationId: string | undefined;
+}
+export declare namespace DeleteHoursOfOperationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteHoursOfOperationRequest) => any;
+}
+export interface DeleteInstanceRequest {
+    
+    InstanceId: string | undefined;
+}
+export declare namespace DeleteInstanceRequest {
+    
+    const filterSensitiveLog: (obj: DeleteInstanceRequest) => any;
+}
+export interface DeleteIntegrationAssociationRequest {
+    
+    InstanceId: string | undefined;
+    
+    IntegrationAssociationId: string | undefined;
+}
+export declare namespace DeleteIntegrationAssociationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteIntegrationAssociationRequest) => any;
+}
+export interface DeleteQuickConnectRequest {
+    
+    InstanceId: string | undefined;
+    
+    QuickConnectId: string | undefined;
+}
+export declare namespace DeleteQuickConnectRequest {
+    
+    const filterSensitiveLog: (obj: DeleteQuickConnectRequest) => any;
+}
+export interface DeleteUseCaseRequest {
+    
+    InstanceId: string | undefined;
+    
+    IntegrationAssociationId: string | undefined;
+    
+    UseCaseId: string | undefined;
+}
+export declare namespace DeleteUseCaseRequest {
+    
+    const filterSensitiveLog: (obj: DeleteUseCaseRequest) => any;
+}
+export interface DeleteUserRequest {
+    
+    InstanceId: string | undefined;
+    
+    UserId: string | undefined;
+}
+export declare namespace DeleteUserRequest {
+    
+    const filterSensitiveLog: (obj: DeleteUserRequest) => any;
+}
+export interface DeleteUserHierarchyGroupRequest {
+    
+    HierarchyGroupId: string | undefined;
+    
+    InstanceId: string | undefined;
+}
+export declare namespace DeleteUserHierarchyGroupRequest {
+    
+    const filterSensitiveLog: (obj: DeleteUserHierarchyGroupRequest) => any;
+}
+export declare enum ResourceType {
+    CONTACT = "CONTACT",
+    CONTACT_FLOW = "CONTACT_FLOW",
+    HIERARCHY_GROUP = "HIERARCHY_GROUP",
+    HIERARCHY_LEVEL = "HIERARCHY_LEVEL",
+    INSTANCE = "INSTANCE",
+    PARTICIPANT = "PARTICIPANT",
+    USER = "USER"
+}
+
+export interface ResourceInUseException extends __SmithyException, $MetadataBearer {
+    name: "ResourceInUseException";
+    $fault: "client";
+    Message?: string;
+    
+    ResourceType?: ResourceType | string;
+    
+    ResourceId?: string;
+}
+export declare namespace ResourceInUseException {
+    
+    const filterSensitiveLog: (obj: ResourceInUseException) => any;
+}
+export interface DescribeAgentStatusRequest {
+    
+    InstanceId: string | undefined;
+    
+    AgentStatusId: string | undefined;
+}
+export declare namespace DescribeAgentStatusRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAgentStatusRequest) => any;
+}
+export interface DescribeAgentStatusResponse {
+    
+    AgentStatus?: AgentStatus;
+}
+export declare namespace DescribeAgentStatusResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAgentStatusResponse) => any;
+}
+
+export interface ContactFlowNotPublishedException extends __SmithyException, $MetadataBearer {
+    name: "ContactFlowNotPublishedException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace ContactFlowNotPublishedException {
+    
+    const filterSensitiveLog: (obj: ContactFlowNotPublishedException) => any;
+}
+export interface DescribeContactFlowRequest {
+    
+    InstanceId: string | undefined;
+    
+    ContactFlowId: string | undefined;
+}
+export declare namespace DescribeContactFlowRequest {
+    
+    const filterSensitiveLog: (obj: DescribeContactFlowRequest) => any;
+}
+
+export interface ContactFlow {
+    
+    Arn?: string;
+    
+    Id?: string;
+    
+    Name?: string;
+    
+    Type?: ContactFlowType | string;
+    
+    Description?: string;
+    
+    Content?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ContactFlow {
+    
+    const filterSensitiveLog: (obj: ContactFlow) => any;
+}
+export interface DescribeContactFlowResponse {
+    
+    ContactFlow?: ContactFlow;
+}
+export declare namespace DescribeContactFlowResponse {
+    
+    const filterSensitiveLog: (obj: DescribeContactFlowResponse) => any;
+}
+export interface DescribeHoursOfOperationRequest {
+    
+    InstanceId: string | undefined;
+    
+    HoursOfOperationId: string | undefined;
+}
+export declare namespace DescribeHoursOfOperationRequest {
+    
+    const filterSensitiveLog: (obj: DescribeHoursOfOperationRequest) => any;
+}
+
+export interface HoursOfOperation {
+    
+    HoursOfOperationId?: string;
+    
+    HoursOfOperationArn?: string;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    TimeZone?: string;
+    
+    Config?: HoursOfOperationConfig[];
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace HoursOfOperation {
+    
+    const filterSensitiveLog: (obj: HoursOfOperation) => any;
+}
+export interface DescribeHoursOfOperationResponse {
+    
+    HoursOfOperation?: HoursOfOperation;
+}
+export declare namespace DescribeHoursOfOperationResponse {
+    
+    const filterSensitiveLog: (obj: DescribeHoursOfOperationResponse) => any;
+}
+export interface DescribeInstanceRequest {
+    
+    InstanceId: string | undefined;
+}
+export declare namespace DescribeInstanceRequest {
+    
+    const filterSensitiveLog: (obj: DescribeInstanceRequest) => any;
+}
+export declare enum InstanceStatus {
+    ACTIVE = "ACTIVE",
+    CREATION_FAILED = "CREATION_FAILED",
+    CREATION_IN_PROGRESS = "CREATION_IN_PROGRESS"
+}
+
+export interface InstanceStatusReason {
+    
+    Message?: string;
+}
+export declare namespace InstanceStatusReason {
+    
+    const filterSensitiveLog: (obj: InstanceStatusReason) => any;
+}
+
+export interface Instance {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    IdentityManagementType?: DirectoryType | string;
+    
+    InstanceAlias?: string;
+    
+    CreatedTime?: Date;
+    
+    ServiceRole?: string;
+    
+    InstanceStatus?: InstanceStatus | string;
+    
+    StatusReason?: InstanceStatusReason;
+    
+    InboundCallsEnabled?: boolean;
+    
+    OutboundCallsEnabled?: boolean;
+}
+export declare namespace Instance {
+    
+    const filterSensitiveLog: (obj: Instance) => any;
+}
+export interface DescribeInstanceResponse {
+    
+    Instance?: Instance;
+}
+export declare namespace DescribeInstanceResponse {
+    
+    const filterSensitiveLog: (obj: DescribeInstanceResponse) => any;
+}
+export declare enum InstanceAttributeType {
+    AUTO_RESOLVE_BEST_VOICES = "AUTO_RESOLVE_BEST_VOICES",
+    CONTACTFLOW_LOGS = "CONTACTFLOW_LOGS",
+    CONTACT_LENS = "CONTACT_LENS",
+    EARLY_MEDIA = "EARLY_MEDIA",
+    INBOUND_CALLS = "INBOUND_CALLS",
+    OUTBOUND_CALLS = "OUTBOUND_CALLS",
+    USE_CUSTOM_TTS_VOICES = "USE_CUSTOM_TTS_VOICES"
+}
+export interface DescribeInstanceAttributeRequest {
+    
+    InstanceId: string | undefined;
+    
+    AttributeType: InstanceAttributeType | string | undefined;
+}
+export declare namespace DescribeInstanceAttributeRequest {
+    
+    const filterSensitiveLog: (obj: DescribeInstanceAttributeRequest) => any;
+}
+
+export interface Attribute {
+    
+    AttributeType?: InstanceAttributeType | string;
+    
+    Value?: string;
+}
+export declare namespace Attribute {
+    
+    const filterSensitiveLog: (obj: Attribute) => any;
+}
+export interface DescribeInstanceAttributeResponse {
+    
+    Attribute?: Attribute;
+}
+export declare namespace DescribeInstanceAttributeResponse {
+    
+    const filterSensitiveLog: (obj: DescribeInstanceAttributeResponse) => any;
+}
+export interface DescribeInstanceStorageConfigRequest {
+    
+    InstanceId: string | undefined;
+    
+    AssociationId: string | undefined;
+    
+    ResourceType: InstanceStorageResourceType | string | undefined;
+}
+export declare namespace DescribeInstanceStorageConfigRequest {
+    
+    const filterSensitiveLog: (obj: DescribeInstanceStorageConfigRequest) => any;
+}
+export interface DescribeInstanceStorageConfigResponse {
+    
+    StorageConfig?: InstanceStorageConfig;
+}
+export declare namespace DescribeInstanceStorageConfigResponse {
+    
+    const filterSensitiveLog: (obj: DescribeInstanceStorageConfigResponse) => any;
+}
+export interface DescribeQueueRequest {
+    
+    InstanceId: string | undefined;
+    
+    QueueId: string | undefined;
+}
+export declare namespace DescribeQueueRequest {
+    
+    const filterSensitiveLog: (obj: DescribeQueueRequest) => any;
+}
+export declare enum QueueStatus {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface Queue {
+    
+    Name?: string;
+    
+    QueueArn?: string;
+    
+    QueueId?: string;
+    
+    Description?: string;
+    
+    OutboundCallerConfig?: OutboundCallerConfig;
+    
+    HoursOfOperationId?: string;
+    
+    MaxContacts?: number;
+    
+    Status?: QueueStatus | string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace Queue {
+    
+    const filterSensitiveLog: (obj: Queue) => any;
+}
+export interface DescribeQueueResponse {
+    
+    Queue?: Queue;
+}
+export declare namespace DescribeQueueResponse {
+    
+    const filterSensitiveLog: (obj: DescribeQueueResponse) => any;
+}
+export interface DescribeQuickConnectRequest {
+    
+    InstanceId: string | undefined;
+    
+    QuickConnectId: string | undefined;
+}
+export declare namespace DescribeQuickConnectRequest {
+    
+    const filterSensitiveLog: (obj: DescribeQuickConnectRequest) => any;
+}
+
+export interface QuickConnect {
+    
+    QuickConnectARN?: string;
+    
+    QuickConnectId?: string;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    QuickConnectConfig?: QuickConnectConfig;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace QuickConnect {
+    
+    const filterSensitiveLog: (obj: QuickConnect) => any;
+}
+export interface DescribeQuickConnectResponse {
+    
+    QuickConnect?: QuickConnect;
+}
+export declare namespace DescribeQuickConnectResponse {
+    
+    const filterSensitiveLog: (obj: DescribeQuickConnectResponse) => any;
+}
+export interface DescribeRoutingProfileRequest {
+    
+    InstanceId: string | undefined;
+    
+    RoutingProfileId: string | undefined;
+}
+export declare namespace DescribeRoutingProfileRequest {
+    
+    const filterSensitiveLog: (obj: DescribeRoutingProfileRequest) => any;
+}
+
+export interface RoutingProfile {
+    
+    InstanceId?: string;
+    
+    Name?: string;
+    
+    RoutingProfileArn?: string;
+    
+    RoutingProfileId?: string;
+    
+    Description?: string;
+    
+    MediaConcurrencies?: MediaConcurrency[];
+    
+    DefaultOutboundQueueId?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace RoutingProfile {
+    
+    const filterSensitiveLog: (obj: RoutingProfile) => any;
+}
+export interface DescribeRoutingProfileResponse {
+    
+    RoutingProfile?: RoutingProfile;
+}
+export declare namespace DescribeRoutingProfileResponse {
+    
+    const filterSensitiveLog: (obj: DescribeRoutingProfileResponse) => any;
+}
+export interface DescribeUserRequest {
+    
+    UserId: string | undefined;
+    
+    InstanceId: string | undefined;
+}
+export declare namespace DescribeUserRequest {
+    
+    const filterSensitiveLog: (obj: DescribeUserRequest) => any;
+}
+
+export interface User {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Username?: string;
+    
+    IdentityInfo?: UserIdentityInfo;
+    
+    PhoneConfig?: UserPhoneConfig;
+    
+    DirectoryUserId?: string;
+    
+    SecurityProfileIds?: string[];
+    
+    RoutingProfileId?: string;
+    
+    HierarchyGroupId?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace User {
+    
+    const filterSensitiveLog: (obj: User) => any;
+}
+export interface DescribeUserResponse {
+    
+    User?: User;
+}
+export declare namespace DescribeUserResponse {
+    
+    const filterSensitiveLog: (obj: DescribeUserResponse) => any;
+}
+export interface DescribeUserHierarchyGroupRequest {
+    
+    HierarchyGroupId: string | undefined;
+    
+    InstanceId: string | undefined;
+}
+export declare namespace DescribeUserHierarchyGroupRequest {
+    
+    const filterSensitiveLog: (obj: DescribeUserHierarchyGroupRequest) => any;
+}
+
+export interface HierarchyGroupSummary {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Name?: string;
+}
+export declare namespace HierarchyGroupSummary {
+    
+    const filterSensitiveLog: (obj: HierarchyGroupSummary) => any;
+}
+
+export interface HierarchyPath {
+    
+    LevelOne?: HierarchyGroupSummary;
+    
+    LevelTwo?: HierarchyGroupSummary;
+    
+    LevelThree?: HierarchyGroupSummary;
+    
+    LevelFour?: HierarchyGroupSummary;
+    
+    LevelFive?: HierarchyGroupSummary;
+}
+export declare namespace HierarchyPath {
+    
+    const filterSensitiveLog: (obj: HierarchyPath) => any;
+}
+
+export interface HierarchyGroup {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Name?: string;
+    
+    LevelId?: string;
+    
+    HierarchyPath?: HierarchyPath;
+}
+export declare namespace HierarchyGroup {
+    
+    const filterSensitiveLog: (obj: HierarchyGroup) => any;
+}
+export interface DescribeUserHierarchyGroupResponse {
+    
+    HierarchyGroup?: HierarchyGroup;
+}
+export declare namespace DescribeUserHierarchyGroupResponse {
+    
+    const filterSensitiveLog: (obj: DescribeUserHierarchyGroupResponse) => any;
+}
+export interface DescribeUserHierarchyStructureRequest {
+    
+    InstanceId: string | undefined;
+}
+export declare namespace DescribeUserHierarchyStructureRequest {
+    
+    const filterSensitiveLog: (obj: DescribeUserHierarchyStructureRequest) => any;
+}
+
+export interface HierarchyLevel {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Name?: string;
+}
+export declare namespace HierarchyLevel {
+    
+    const filterSensitiveLog: (obj: HierarchyLevel) => any;
+}
+
+export interface HierarchyStructure {
+    
+    LevelOne?: HierarchyLevel;
+    
+    LevelTwo?: HierarchyLevel;
+    
+    LevelThree?: HierarchyLevel;
+    
+    LevelFour?: HierarchyLevel;
+    
+    LevelFive?: HierarchyLevel;
+}
+export declare namespace HierarchyStructure {
+    
+    const filterSensitiveLog: (obj: HierarchyStructure) => any;
+}
+export interface DescribeUserHierarchyStructureResponse {
+    
+    HierarchyStructure?: HierarchyStructure;
+}
+export declare namespace DescribeUserHierarchyStructureResponse {
+    
+    const filterSensitiveLog: (obj: DescribeUserHierarchyStructureResponse) => any;
+}
+export interface DisassociateApprovedOriginRequest {
+    
+    InstanceId: string | undefined;
+    
+    Origin: string | undefined;
+}
+export declare namespace DisassociateApprovedOriginRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateApprovedOriginRequest) => any;
+}
+export interface DisassociateBotRequest {
+    
+    InstanceId: string | undefined;
+    
+    LexBot?: LexBot;
+    
+    LexV2Bot?: LexV2Bot;
+}
+export declare namespace DisassociateBotRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateBotRequest) => any;
+}
+export interface DisassociateInstanceStorageConfigRequest {
+    
+    InstanceId: string | undefined;
+    
+    AssociationId: string | undefined;
+    
+    ResourceType: InstanceStorageResourceType | string | undefined;
+}
+export declare namespace DisassociateInstanceStorageConfigRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateInstanceStorageConfigRequest) => any;
+}
+export interface DisassociateLambdaFunctionRequest {
+    
+    InstanceId: string | undefined;
+    
+    FunctionArn: string | undefined;
+}
+export declare namespace DisassociateLambdaFunctionRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateLambdaFunctionRequest) => any;
+}
+export interface DisassociateLexBotRequest {
+    
+    InstanceId: string | undefined;
+    
+    BotName: string | undefined;
+    
+    LexRegion: string | undefined;
+}
+export declare namespace DisassociateLexBotRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateLexBotRequest) => any;
+}
+export interface DisassociateQueueQuickConnectsRequest {
+    
+    InstanceId: string | undefined;
+    
+    QueueId: string | undefined;
+    
+    QuickConnectIds: string[] | undefined;
+}
+export declare namespace DisassociateQueueQuickConnectsRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateQueueQuickConnectsRequest) => any;
+}
+export interface DisassociateRoutingProfileQueuesRequest {
+    
+    InstanceId: string | undefined;
+    
+    RoutingProfileId: string | undefined;
+    
+    QueueReferences: RoutingProfileQueueReference[] | undefined;
+}
+export declare namespace DisassociateRoutingProfileQueuesRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateRoutingProfileQueuesRequest) => any;
+}
+export interface DisassociateSecurityKeyRequest {
+    
+    InstanceId: string | undefined;
+    
+    AssociationId: string | undefined;
+}
+export declare namespace DisassociateSecurityKeyRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateSecurityKeyRequest) => any;
+}
+export interface GetContactAttributesRequest {
+    
+    InstanceId: string | undefined;
+    
+    InitialContactId: string | undefined;
+}
+export declare namespace GetContactAttributesRequest {
+    
+    const filterSensitiveLog: (obj: GetContactAttributesRequest) => any;
+}
+export interface GetContactAttributesResponse {
+    
+    Attributes?: {
+        [key: string]: string;
+    };
+}
+export declare namespace GetContactAttributesResponse {
+    
+    const filterSensitiveLog: (obj: GetContactAttributesResponse) => any;
+}
+export declare enum CurrentMetricName {
+    AGENTS_AFTER_CONTACT_WORK = "AGENTS_AFTER_CONTACT_WORK",
+    AGENTS_AVAILABLE = "AGENTS_AVAILABLE",
+    AGENTS_ERROR = "AGENTS_ERROR",
+    AGENTS_NON_PRODUCTIVE = "AGENTS_NON_PRODUCTIVE",
+    AGENTS_ONLINE = "AGENTS_ONLINE",
+    AGENTS_ON_CALL = "AGENTS_ON_CALL",
+    AGENTS_ON_CONTACT = "AGENTS_ON_CONTACT",
+    AGENTS_STAFFED = "AGENTS_STAFFED",
+    CONTACTS_IN_QUEUE = "CONTACTS_IN_QUEUE",
+    CONTACTS_SCHEDULED = "CONTACTS_SCHEDULED",
+    OLDEST_CONTACT_AGE = "OLDEST_CONTACT_AGE",
+    SLOTS_ACTIVE = "SLOTS_ACTIVE",
+    SLOTS_AVAILABLE = "SLOTS_AVAILABLE"
+}
+export declare enum Unit {
+    COUNT = "COUNT",
+    PERCENT = "PERCENT",
+    SECONDS = "SECONDS"
+}
+
+export interface CurrentMetric {
+    
+    Name?: CurrentMetricName | string;
+    
+    Unit?: Unit | string;
+}
+export declare namespace CurrentMetric {
+    
+    const filterSensitiveLog: (obj: CurrentMetric) => any;
+}
+
+export interface Filters {
+    
+    Queues?: string[];
+    
+    Channels?: (Channel | string)[];
+}
+export declare namespace Filters {
+    
+    const filterSensitiveLog: (obj: Filters) => any;
+}
+export declare enum Grouping {
+    CHANNEL = "CHANNEL",
+    QUEUE = "QUEUE"
+}
+export interface GetCurrentMetricDataRequest {
+    
+    InstanceId: string | undefined;
+    
+    Filters: Filters | undefined;
+    
+    Groupings?: (Grouping | string)[];
+    
+    CurrentMetrics: CurrentMetric[] | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace GetCurrentMetricDataRequest {
+    
+    const filterSensitiveLog: (obj: GetCurrentMetricDataRequest) => any;
+}
+
+export interface CurrentMetricData {
+    
+    Metric?: CurrentMetric;
+    
+    Value?: number;
+}
+export declare namespace CurrentMetricData {
+    
+    const filterSensitiveLog: (obj: CurrentMetricData) => any;
+}
+
+export interface QueueReference {
+    
+    Id?: string;
+    
+    Arn?: string;
+}
+export declare namespace QueueReference {
+    
+    const filterSensitiveLog: (obj: QueueReference) => any;
+}
+
+export interface Dimensions {
+    
+    Queue?: QueueReference;
+    
+    Channel?: Channel | string;
+}
+export declare namespace Dimensions {
+    
+    const filterSensitiveLog: (obj: Dimensions) => any;
+}
+
+export interface CurrentMetricResult {
+    
+    Dimensions?: Dimensions;
+    
+    Collections?: CurrentMetricData[];
+}
+export declare namespace CurrentMetricResult {
+    
+    const filterSensitiveLog: (obj: CurrentMetricResult) => any;
+}
+export interface GetCurrentMetricDataResponse {
+    
+    NextToken?: string;
+    
+    MetricResults?: CurrentMetricResult[];
+    
+    DataSnapshotTime?: Date;
+}
+export declare namespace GetCurrentMetricDataResponse {
+    
+    const filterSensitiveLog: (obj: GetCurrentMetricDataResponse) => any;
+}
+export interface GetFederationTokenRequest {
+    
+    InstanceId: string | undefined;
+}
+export declare namespace GetFederationTokenRequest {
+    
+    const filterSensitiveLog: (obj: GetFederationTokenRequest) => any;
+}
+
+export interface Credentials {
+    
+    AccessToken?: string;
+    
+    AccessTokenExpiration?: Date;
+    
+    RefreshToken?: string;
+    
+    RefreshTokenExpiration?: Date;
+}
+export declare namespace Credentials {
+    
+    const filterSensitiveLog: (obj: Credentials) => any;
+}
+export interface GetFederationTokenResponse {
+    
+    Credentials?: Credentials;
+}
+export declare namespace GetFederationTokenResponse {
+    
+    const filterSensitiveLog: (obj: GetFederationTokenResponse) => any;
+}
+
+export interface UserNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "UserNotFoundException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace UserNotFoundException {
+    
+    const filterSensitiveLog: (obj: UserNotFoundException) => any;
+}
+export declare enum HistoricalMetricName {
+    ABANDON_TIME = "ABANDON_TIME",
+    AFTER_CONTACT_WORK_TIME = "AFTER_CONTACT_WORK_TIME",
+    API_CONTACTS_HANDLED = "API_CONTACTS_HANDLED",
+    CALLBACK_CONTACTS_HANDLED = "CALLBACK_CONTACTS_HANDLED",
+    CONTACTS_ABANDONED = "CONTACTS_ABANDONED",
+    CONTACTS_AGENT_HUNG_UP_FIRST = "CONTACTS_AGENT_HUNG_UP_FIRST",
+    CONTACTS_CONSULTED = "CONTACTS_CONSULTED",
+    CONTACTS_HANDLED = "CONTACTS_HANDLED",
+    CONTACTS_HANDLED_INCOMING = "CONTACTS_HANDLED_INCOMING",
+    CONTACTS_HANDLED_OUTBOUND = "CONTACTS_HANDLED_OUTBOUND",
+    CONTACTS_HOLD_ABANDONS = "CONTACTS_HOLD_ABANDONS",
+    CONTACTS_MISSED = "CONTACTS_MISSED",
+    CONTACTS_QUEUED = "CONTACTS_QUEUED",
+    CONTACTS_TRANSFERRED_IN = "CONTACTS_TRANSFERRED_IN",
+    CONTACTS_TRANSFERRED_IN_FROM_QUEUE = "CONTACTS_TRANSFERRED_IN_FROM_QUEUE",
+    CONTACTS_TRANSFERRED_OUT = "CONTACTS_TRANSFERRED_OUT",
+    CONTACTS_TRANSFERRED_OUT_FROM_QUEUE = "CONTACTS_TRANSFERRED_OUT_FROM_QUEUE",
+    HANDLE_TIME = "HANDLE_TIME",
+    HOLD_TIME = "HOLD_TIME",
+    INTERACTION_AND_HOLD_TIME = "INTERACTION_AND_HOLD_TIME",
+    INTERACTION_TIME = "INTERACTION_TIME",
+    OCCUPANCY = "OCCUPANCY",
+    QUEUED_TIME = "QUEUED_TIME",
+    QUEUE_ANSWER_TIME = "QUEUE_ANSWER_TIME",
+    SERVICE_LEVEL = "SERVICE_LEVEL"
+}
+export declare enum Statistic {
+    AVG = "AVG",
+    MAX = "MAX",
+    SUM = "SUM"
+}
+export declare enum Comparison {
+    LT = "LT"
+}
+
+export interface Threshold {
+    
+    Comparison?: Comparison | string;
+    
+    ThresholdValue?: number;
+}
+export declare namespace Threshold {
+    
+    const filterSensitiveLog: (obj: Threshold) => any;
+}
+
+export interface HistoricalMetric {
+    
+    Name?: HistoricalMetricName | string;
+    
+    Threshold?: Threshold;
+    
+    Statistic?: Statistic | string;
+    
+    Unit?: Unit | string;
+}
+export declare namespace HistoricalMetric {
+    
+    const filterSensitiveLog: (obj: HistoricalMetric) => any;
+}
+export interface GetMetricDataRequest {
+    
+    InstanceId: string | undefined;
+    
+    StartTime: Date | undefined;
+    
+    EndTime: Date | undefined;
+    
+    Filters: Filters | undefined;
+    
+    Groupings?: (Grouping | string)[];
+    
+    HistoricalMetrics: HistoricalMetric[] | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace GetMetricDataRequest {
+    
+    const filterSensitiveLog: (obj: GetMetricDataRequest) => any;
+}
+
+export interface HistoricalMetricData {
+    
+    Metric?: HistoricalMetric;
+    
+    Value?: number;
+}
+export declare namespace HistoricalMetricData {
+    
+    const filterSensitiveLog: (obj: HistoricalMetricData) => any;
+}
+
+export interface HistoricalMetricResult {
+    
+    Dimensions?: Dimensions;
+    
+    Collections?: HistoricalMetricData[];
+}
+export declare namespace HistoricalMetricResult {
+    
+    const filterSensitiveLog: (obj: HistoricalMetricResult) => any;
+}
+export interface GetMetricDataResponse {
+    
+    NextToken?: string;
+    
+    MetricResults?: HistoricalMetricResult[];
+}
+export declare namespace GetMetricDataResponse {
+    
+    const filterSensitiveLog: (obj: GetMetricDataResponse) => any;
+}
+export interface ListAgentStatusRequest {
+    
+    InstanceId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    AgentStatusTypes?: (AgentStatusType | string)[];
+}
+export declare namespace ListAgentStatusRequest {
+    
+    const filterSensitiveLog: (obj: ListAgentStatusRequest) => any;
+}
+export interface ListAgentStatusResponse {
+    
+    NextToken?: string;
+    
+    AgentStatusSummaryList?: AgentStatusSummary[];
+}
+export declare namespace ListAgentStatusResponse {
+    
+    const filterSensitiveLog: (obj: ListAgentStatusResponse) => any;
+}
+export interface ListApprovedOriginsRequest {
+    
+    InstanceId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListApprovedOriginsRequest {
+    
+    const filterSensitiveLog: (obj: ListApprovedOriginsRequest) => any;
+}
+export interface ListApprovedOriginsResponse {
+    
+    Origins?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace ListApprovedOriginsResponse {
+    
+    const filterSensitiveLog: (obj: ListApprovedOriginsResponse) => any;
+}
+export declare enum LexVersion {
+    V1 = "V1",
+    V2 = "V2"
+}
+export interface ListBotsRequest {
+    
+    InstanceId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    LexVersion: LexVersion | string | undefined;
+}
+export declare namespace ListBotsRequest {
+    
+    const filterSensitiveLog: (obj: ListBotsRequest) => any;
+}
+
+export interface LexBotConfig {
+    
+    LexBot?: LexBot;
+    
+    LexV2Bot?: LexV2Bot;
+}
+export declare namespace LexBotConfig {
+    
+    const filterSensitiveLog: (obj: LexBotConfig) => any;
+}
+export interface ListBotsResponse {
+    
+    LexBots?: LexBotConfig[];
+    
+    NextToken?: string;
+}
+export declare namespace ListBotsResponse {
+    
+    const filterSensitiveLog: (obj: ListBotsResponse) => any;
+}
+export interface ListContactFlowsRequest {
+    
+    InstanceId: string | undefined;
+    
+    ContactFlowTypes?: (ContactFlowType | string)[];
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListContactFlowsRequest {
+    
+    const filterSensitiveLog: (obj: ListContactFlowsRequest) => any;
+}
+
+export interface ContactFlowSummary {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Name?: string;
+    
+    ContactFlowType?: ContactFlowType | string;
+}
+export declare namespace ContactFlowSummary {
+    
+    const filterSensitiveLog: (obj: ContactFlowSummary) => any;
+}
+export interface ListContactFlowsResponse {
+    
+    ContactFlowSummaryList?: ContactFlowSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListContactFlowsResponse {
+    
+    const filterSensitiveLog: (obj: ListContactFlowsResponse) => any;
+}
+export interface ListHoursOfOperationsRequest {
+    
+    InstanceId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListHoursOfOperationsRequest {
+    
+    const filterSensitiveLog: (obj: ListHoursOfOperationsRequest) => any;
+}
+
+export interface HoursOfOperationSummary {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Name?: string;
+}
+export declare namespace HoursOfOperationSummary {
+    
+    const filterSensitiveLog: (obj: HoursOfOperationSummary) => any;
+}
+export interface ListHoursOfOperationsResponse {
+    
+    HoursOfOperationSummaryList?: HoursOfOperationSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListHoursOfOperationsResponse {
+    
+    const filterSensitiveLog: (obj: ListHoursOfOperationsResponse) => any;
+}
+export interface ListInstanceAttributesRequest {
+    
+    InstanceId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListInstanceAttributesRequest {
+    
+    const filterSensitiveLog: (obj: ListInstanceAttributesRequest) => any;
+}
+export interface ListInstanceAttributesResponse {
+    
+    Attributes?: Attribute[];
+    
+    NextToken?: string;
+}
+export declare namespace ListInstanceAttributesResponse {
+    
+    const filterSensitiveLog: (obj: ListInstanceAttributesResponse) => any;
+}
+export interface ListInstancesRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListInstancesRequest {
+    
+    const filterSensitiveLog: (obj: ListInstancesRequest) => any;
+}
+
+export interface InstanceSummary {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    IdentityManagementType?: DirectoryType | string;
+    
+    InstanceAlias?: string;
+    
+    CreatedTime?: Date;
+    
+    ServiceRole?: string;
+    
+    InstanceStatus?: InstanceStatus | string;
+    
+    InboundCallsEnabled?: boolean;
+    
+    OutboundCallsEnabled?: boolean;
+}
+export declare namespace InstanceSummary {
+    
+    const filterSensitiveLog: (obj: InstanceSummary) => any;
+}
+export interface ListInstancesResponse {
+    
+    InstanceSummaryList?: InstanceSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListInstancesResponse {
+    
+    const filterSensitiveLog: (obj: ListInstancesResponse) => any;
+}
+export interface ListInstanceStorageConfigsRequest {
+    
+    InstanceId: string | undefined;
+    
+    ResourceType: InstanceStorageResourceType | string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListInstanceStorageConfigsRequest {
+    
+    const filterSensitiveLog: (obj: ListInstanceStorageConfigsRequest) => any;
+}
+export interface ListInstanceStorageConfigsResponse {
+    
+    StorageConfigs?: InstanceStorageConfig[];
+    
+    NextToken?: string;
+}
+export declare namespace ListInstanceStorageConfigsResponse {
+    
+    const filterSensitiveLog: (obj: ListInstanceStorageConfigsResponse) => any;
+}
+export interface ListIntegrationAssociationsRequest {
+    
+    InstanceId: string | undefined;
+    
+    IntegrationType?: IntegrationType | string;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListIntegrationAssociationsRequest {
+    
+    const filterSensitiveLog: (obj: ListIntegrationAssociationsRequest) => any;
+}
+
+export interface IntegrationAssociationSummary {
+    
+    IntegrationAssociationId?: string;
+    
+    IntegrationAssociationArn?: string;
+    
+    InstanceId?: string;
+    
+    IntegrationType?: IntegrationType | string;
+    
+    IntegrationArn?: string;
+    
+    SourceApplicationUrl?: string;
+    
+    SourceApplicationName?: string;
+    
+    SourceType?: SourceType | string;
+}
+export declare namespace IntegrationAssociationSummary {
+    
+    const filterSensitiveLog: (obj: IntegrationAssociationSummary) => any;
+}
+export interface ListIntegrationAssociationsResponse {
+    
+    IntegrationAssociationSummaryList?: IntegrationAssociationSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListIntegrationAssociationsResponse {
+    
+    const filterSensitiveLog: (obj: ListIntegrationAssociationsResponse) => any;
+}
+export interface ListLambdaFunctionsRequest {
+    
+    InstanceId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListLambdaFunctionsRequest {
+    
+    const filterSensitiveLog: (obj: ListLambdaFunctionsRequest) => any;
+}
+export interface ListLambdaFunctionsResponse {
+    
+    LambdaFunctions?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace ListLambdaFunctionsResponse {
+    
+    const filterSensitiveLog: (obj: ListLambdaFunctionsResponse) => any;
+}
+export interface ListLexBotsRequest {
+    
+    InstanceId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListLexBotsRequest {
+    
+    const filterSensitiveLog: (obj: ListLexBotsRequest) => any;
+}
+export interface ListLexBotsResponse {
+    
+    LexBots?: LexBot[];
+    
+    NextToken?: string;
+}
+export declare namespace ListLexBotsResponse {
+    
+    const filterSensitiveLog: (obj: ListLexBotsResponse) => any;
+}
+export declare enum PhoneNumberCountryCode {
+    AD = "AD",
+    AE = "AE",
+    AF = "AF",
+    AG = "AG",
+    AI = "AI",
+    AL = "AL",
+    AM = "AM",
+    AN = "AN",
+    AO = "AO",
+    AQ = "AQ",
+    AR = "AR",
+    AS = "AS",
+    AT = "AT",
+    AU = "AU",
+    AW = "AW",
+    AZ = "AZ",
+    BA = "BA",
+    BB = "BB",
+    BD = "BD",
+    BE = "BE",
+    BF = "BF",
+    BG = "BG",
+    BH = "BH",
+    BI = "BI",
+    BJ = "BJ",
+    BL = "BL",
+    BM = "BM",
+    BN = "BN",
+    BO = "BO",
+    BR = "BR",
+    BS = "BS",
+    BT = "BT",
+    BW = "BW",
+    BY = "BY",
+    BZ = "BZ",
+    CA = "CA",
+    CC = "CC",
+    CD = "CD",
+    CF = "CF",
+    CG = "CG",
+    CH = "CH",
+    CI = "CI",
+    CK = "CK",
+    CL = "CL",
+    CM = "CM",
+    CN = "CN",
+    CO = "CO",
+    CR = "CR",
+    CU = "CU",
+    CV = "CV",
+    CW = "CW",
+    CX = "CX",
+    CY = "CY",
+    CZ = "CZ",
+    DE = "DE",
+    DJ = "DJ",
+    DK = "DK",
+    DM = "DM",
+    DO = "DO",
+    DZ = "DZ",
+    EC = "EC",
+    EE = "EE",
+    EG = "EG",
+    EH = "EH",
+    ER = "ER",
+    ES = "ES",
+    ET = "ET",
+    FI = "FI",
+    FJ = "FJ",
+    FK = "FK",
+    FM = "FM",
+    FO = "FO",
+    FR = "FR",
+    GA = "GA",
+    GB = "GB",
+    GD = "GD",
+    GE = "GE",
+    GG = "GG",
+    GH = "GH",
+    GI = "GI",
+    GL = "GL",
+    GM = "GM",
+    GN = "GN",
+    GQ = "GQ",
+    GR = "GR",
+    GT = "GT",
+    GU = "GU",
+    GW = "GW",
+    GY = "GY",
+    HK = "HK",
+    HN = "HN",
+    HR = "HR",
+    HT = "HT",
+    HU = "HU",
+    ID = "ID",
+    IE = "IE",
+    IL = "IL",
+    IM = "IM",
+    IN = "IN",
+    IO = "IO",
+    IQ = "IQ",
+    IR = "IR",
+    IS = "IS",
+    IT = "IT",
+    JE = "JE",
+    JM = "JM",
+    JO = "JO",
+    JP = "JP",
+    KE = "KE",
+    KG = "KG",
+    KH = "KH",
+    KI = "KI",
+    KM = "KM",
+    KN = "KN",
+    KP = "KP",
+    KR = "KR",
+    KW = "KW",
+    KY = "KY",
+    KZ = "KZ",
+    LA = "LA",
+    LB = "LB",
+    LC = "LC",
+    LI = "LI",
+    LK = "LK",
+    LR = "LR",
+    LS = "LS",
+    LT = "LT",
+    LU = "LU",
+    LV = "LV",
+    LY = "LY",
+    MA = "MA",
+    MC = "MC",
+    MD = "MD",
+    ME = "ME",
+    MF = "MF",
+    MG = "MG",
+    MH = "MH",
+    MK = "MK",
+    ML = "ML",
+    MM = "MM",
+    MN = "MN",
+    MO = "MO",
+    MP = "MP",
+    MR = "MR",
+    MS = "MS",
+    MT = "MT",
+    MU = "MU",
+    MV = "MV",
+    MW = "MW",
+    MX = "MX",
+    MY = "MY",
+    MZ = "MZ",
+    NA = "NA",
+    NC = "NC",
+    NE = "NE",
+    NG = "NG",
+    NI = "NI",
+    NL = "NL",
+    NO = "NO",
+    NP = "NP",
+    NR = "NR",
+    NU = "NU",
+    NZ = "NZ",
+    OM = "OM",
+    PA = "PA",
+    PE = "PE",
+    PF = "PF",
+    PG = "PG",
+    PH = "PH",
+    PK = "PK",
+    PL = "PL",
+    PM = "PM",
+    PN = "PN",
+    PR = "PR",
+    PT = "PT",
+    PW = "PW",
+    PY = "PY",
+    QA = "QA",
+    RE = "RE",
+    RO = "RO",
+    RS = "RS",
+    RU = "RU",
+    RW = "RW",
+    SA = "SA",
+    SB = "SB",
+    SC = "SC",
+    SD = "SD",
+    SE = "SE",
+    SG = "SG",
+    SH = "SH",
+    SI = "SI",
+    SJ = "SJ",
+    SK = "SK",
+    SL = "SL",
+    SM = "SM",
+    SN = "SN",
+    SO = "SO",
+    SR = "SR",
+    ST = "ST",
+    SV = "SV",
+    SX = "SX",
+    SY = "SY",
+    SZ = "SZ",
+    TC = "TC",
+    TD = "TD",
+    TG = "TG",
+    TH = "TH",
+    TJ = "TJ",
+    TK = "TK",
+    TL = "TL",
+    TM = "TM",
+    TN = "TN",
+    TO = "TO",
+    TR = "TR",
+    TT = "TT",
+    TV = "TV",
+    TW = "TW",
+    TZ = "TZ",
+    UA = "UA",
+    UG = "UG",
+    US = "US",
+    UY = "UY",
+    UZ = "UZ",
+    VA = "VA",
+    VC = "VC",
+    VE = "VE",
+    VG = "VG",
+    VI = "VI",
+    VN = "VN",
+    VU = "VU",
+    WF = "WF",
+    WS = "WS",
+    YE = "YE",
+    YT = "YT",
+    ZA = "ZA",
+    ZM = "ZM",
+    ZW = "ZW"
+}
+export declare enum PhoneNumberType {
+    DID = "DID",
+    TOLL_FREE = "TOLL_FREE"
+}
+export interface ListPhoneNumbersRequest {
+    
+    InstanceId: string | undefined;
+    
+    PhoneNumberTypes?: (PhoneNumberType | string)[];
+    
+    PhoneNumberCountryCodes?: (PhoneNumberCountryCode | string)[];
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListPhoneNumbersRequest {
+    
+    const filterSensitiveLog: (obj: ListPhoneNumbersRequest) => any;
+}
+
+export interface PhoneNumberSummary {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    PhoneNumber?: string;
+    
+    PhoneNumberType?: PhoneNumberType | string;
+    
+    PhoneNumberCountryCode?: PhoneNumberCountryCode | string;
+}
+export declare namespace PhoneNumberSummary {
+    
+    const filterSensitiveLog: (obj: PhoneNumberSummary) => any;
+}
+export interface ListPhoneNumbersResponse {
+    
+    PhoneNumberSummaryList?: PhoneNumberSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListPhoneNumbersResponse {
+    
+    const filterSensitiveLog: (obj: ListPhoneNumbersResponse) => any;
+}
+export interface ListPromptsRequest {
+    
+    InstanceId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListPromptsRequest {
+    
+    const filterSensitiveLog: (obj: ListPromptsRequest) => any;
+}
+
+export interface PromptSummary {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Name?: string;
+}
+export declare namespace PromptSummary {
+    
+    const filterSensitiveLog: (obj: PromptSummary) => any;
+}
+export interface ListPromptsResponse {
+    
+    PromptSummaryList?: PromptSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListPromptsResponse {
+    
+    const filterSensitiveLog: (obj: ListPromptsResponse) => any;
+}
+export interface ListQueueQuickConnectsRequest {
+    
+    InstanceId: string | undefined;
+    
+    QueueId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListQueueQuickConnectsRequest {
+    
+    const filterSensitiveLog: (obj: ListQueueQuickConnectsRequest) => any;
+}
+
+export interface QuickConnectSummary {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Name?: string;
+    
+    QuickConnectType?: QuickConnectType | string;
+}
+export declare namespace QuickConnectSummary {
+    
+    const filterSensitiveLog: (obj: QuickConnectSummary) => any;
+}
+export interface ListQueueQuickConnectsResponse {
+    
+    NextToken?: string;
+    
+    QuickConnectSummaryList?: QuickConnectSummary[];
+}
+export declare namespace ListQueueQuickConnectsResponse {
+    
+    const filterSensitiveLog: (obj: ListQueueQuickConnectsResponse) => any;
+}
+export declare enum QueueType {
+    AGENT = "AGENT",
+    STANDARD = "STANDARD"
+}
+export interface ListQueuesRequest {
+    
+    InstanceId: string | undefined;
+    
+    QueueTypes?: (QueueType | string)[];
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListQueuesRequest {
+    
+    const filterSensitiveLog: (obj: ListQueuesRequest) => any;
+}
+
+export interface QueueSummary {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Name?: string;
+    
+    QueueType?: QueueType | string;
+}
+export declare namespace QueueSummary {
+    
+    const filterSensitiveLog: (obj: QueueSummary) => any;
+}
+export interface ListQueuesResponse {
+    
+    QueueSummaryList?: QueueSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListQueuesResponse {
+    
+    const filterSensitiveLog: (obj: ListQueuesResponse) => any;
+}
+export interface ListQuickConnectsRequest {
+    
+    InstanceId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    QuickConnectTypes?: (QuickConnectType | string)[];
+}
+export declare namespace ListQuickConnectsRequest {
+    
+    const filterSensitiveLog: (obj: ListQuickConnectsRequest) => any;
+}
+export interface ListQuickConnectsResponse {
+    
+    QuickConnectSummaryList?: QuickConnectSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListQuickConnectsResponse {
+    
+    const filterSensitiveLog: (obj: ListQuickConnectsResponse) => any;
+}
+export interface ListRoutingProfileQueuesRequest {
+    
+    InstanceId: string | undefined;
+    
+    RoutingProfileId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListRoutingProfileQueuesRequest {
+    
+    const filterSensitiveLog: (obj: ListRoutingProfileQueuesRequest) => any;
+}
+
+export interface RoutingProfileQueueConfigSummary {
+    
+    QueueId: string | undefined;
+    
+    QueueArn: string | undefined;
+    
+    QueueName: string | undefined;
+    
+    Priority: number | undefined;
+    
+    Delay: number | undefined;
+    
+    Channel: Channel | string | undefined;
+}
+export declare namespace RoutingProfileQueueConfigSummary {
+    
+    const filterSensitiveLog: (obj: RoutingProfileQueueConfigSummary) => any;
+}
+export interface ListRoutingProfileQueuesResponse {
+    
+    NextToken?: string;
+    
+    RoutingProfileQueueConfigSummaryList?: RoutingProfileQueueConfigSummary[];
+}
+export declare namespace ListRoutingProfileQueuesResponse {
+    
+    const filterSensitiveLog: (obj: ListRoutingProfileQueuesResponse) => any;
+}
+export interface ListRoutingProfilesRequest {
+    
+    InstanceId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListRoutingProfilesRequest {
+    
+    const filterSensitiveLog: (obj: ListRoutingProfilesRequest) => any;
+}
+
+export interface RoutingProfileSummary {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Name?: string;
+}
+export declare namespace RoutingProfileSummary {
+    
+    const filterSensitiveLog: (obj: RoutingProfileSummary) => any;
+}
+export interface ListRoutingProfilesResponse {
+    
+    RoutingProfileSummaryList?: RoutingProfileSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListRoutingProfilesResponse {
+    
+    const filterSensitiveLog: (obj: ListRoutingProfilesResponse) => any;
+}
+export interface ListSecurityKeysRequest {
+    
+    InstanceId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListSecurityKeysRequest {
+    
+    const filterSensitiveLog: (obj: ListSecurityKeysRequest) => any;
+}
+
+export interface SecurityKey {
+    
+    AssociationId?: string;
+    
+    Key?: string;
+    
+    CreationTime?: Date;
+}
+export declare namespace SecurityKey {
+    
+    const filterSensitiveLog: (obj: SecurityKey) => any;
+}
+export interface ListSecurityKeysResponse {
+    
+    SecurityKeys?: SecurityKey[];
+    
+    NextToken?: string;
+}
+export declare namespace ListSecurityKeysResponse {
+    
+    const filterSensitiveLog: (obj: ListSecurityKeysResponse) => any;
+}
+export interface ListSecurityProfilesRequest {
+    
+    InstanceId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListSecurityProfilesRequest {
+    
+    const filterSensitiveLog: (obj: ListSecurityProfilesRequest) => any;
+}
+
+export interface SecurityProfileSummary {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Name?: string;
+}
+export declare namespace SecurityProfileSummary {
+    
+    const filterSensitiveLog: (obj: SecurityProfileSummary) => any;
+}
+export interface ListSecurityProfilesResponse {
+    
+    SecurityProfileSummaryList?: SecurityProfileSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListSecurityProfilesResponse {
+    
+    const filterSensitiveLog: (obj: ListSecurityProfilesResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    resourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+
+export interface ListUseCasesRequest {
+    
+    InstanceId: string | undefined;
+    
+    IntegrationAssociationId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListUseCasesRequest {
+    
+    const filterSensitiveLog: (obj: ListUseCasesRequest) => any;
+}
+
+export interface UseCase {
+    
+    UseCaseId?: string;
+    
+    UseCaseArn?: string;
+    
+    UseCaseType?: UseCaseType | string;
+}
+export declare namespace UseCase {
+    
+    const filterSensitiveLog: (obj: UseCase) => any;
+}
+export interface ListUseCasesResponse {
+    
+    UseCaseSummaryList?: UseCase[];
+    
+    NextToken?: string;
+}
+export declare namespace ListUseCasesResponse {
+    
+    const filterSensitiveLog: (obj: ListUseCasesResponse) => any;
+}
+export interface ListUserHierarchyGroupsRequest {
+    
+    InstanceId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListUserHierarchyGroupsRequest {
+    
+    const filterSensitiveLog: (obj: ListUserHierarchyGroupsRequest) => any;
+}
+export interface ListUserHierarchyGroupsResponse {
+    
+    UserHierarchyGroupSummaryList?: HierarchyGroupSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListUserHierarchyGroupsResponse {
+    
+    const filterSensitiveLog: (obj: ListUserHierarchyGroupsResponse) => any;
+}
+export interface ListUsersRequest {
+    
+    InstanceId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListUsersRequest {
+    
+    const filterSensitiveLog: (obj: ListUsersRequest) => any;
+}
+
+export interface UserSummary {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Username?: string;
+}
+export declare namespace UserSummary {
+    
+    const filterSensitiveLog: (obj: UserSummary) => any;
+}
+export interface ListUsersResponse {
+    
+    UserSummaryList?: UserSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListUsersResponse {
+    
+    const filterSensitiveLog: (obj: ListUsersResponse) => any;
+}
+export interface ResumeContactRecordingRequest {
+    
+    InstanceId: string | undefined;
+    
+    ContactId: string | undefined;
+    
+    InitialContactId: string | undefined;
+}
+export declare namespace ResumeContactRecordingRequest {
+    
+    const filterSensitiveLog: (obj: ResumeContactRecordingRequest) => any;
+}
+export interface ResumeContactRecordingResponse {
+}
+export declare namespace ResumeContactRecordingResponse {
+    
+    const filterSensitiveLog: (obj: ResumeContactRecordingResponse) => any;
+}
+
+export interface ChatMessage {
+    
+    ContentType: string | undefined;
+    
+    Content: string | undefined;
+}
+export declare namespace ChatMessage {
+    
+    const filterSensitiveLog: (obj: ChatMessage) => any;
+}
+
+export interface ParticipantDetails {
+    
+    DisplayName: string | undefined;
+}
+export declare namespace ParticipantDetails {
+    
+    const filterSensitiveLog: (obj: ParticipantDetails) => any;
+}
+export interface StartChatContactRequest {
+    
+    InstanceId: string | undefined;
+    
+    ContactFlowId: string | undefined;
+    
+    Attributes?: {
+        [key: string]: string;
+    };
+    
+    ParticipantDetails: ParticipantDetails | undefined;
+    
+    InitialMessage?: ChatMessage;
+    
+    ClientToken?: string;
+}
+export declare namespace StartChatContactRequest {
+    
+    const filterSensitiveLog: (obj: StartChatContactRequest) => any;
+}
+export interface StartChatContactResponse {
+    
+    ContactId?: string;
+    
+    ParticipantId?: string;
+    
+    ParticipantToken?: string;
+}
+export declare namespace StartChatContactResponse {
+    
+    const filterSensitiveLog: (obj: StartChatContactResponse) => any;
+}
+export declare enum VoiceRecordingTrack {
+    ALL = "ALL",
+    FROM_AGENT = "FROM_AGENT",
+    TO_AGENT = "TO_AGENT"
+}
+
+export interface VoiceRecordingConfiguration {
+    
+    VoiceRecordingTrack?: VoiceRecordingTrack | string;
+}
+export declare namespace VoiceRecordingConfiguration {
+    
+    const filterSensitiveLog: (obj: VoiceRecordingConfiguration) => any;
+}
+export interface StartContactRecordingRequest {
+    
+    InstanceId: string | undefined;
+    
+    ContactId: string | undefined;
+    
+    InitialContactId: string | undefined;
+    
+    VoiceRecordingConfiguration: VoiceRecordingConfiguration | undefined;
+}
+export declare namespace StartContactRecordingRequest {
+    
+    const filterSensitiveLog: (obj: StartContactRecordingRequest) => any;
+}
+export interface StartContactRecordingResponse {
+}
+export declare namespace StartContactRecordingResponse {
+    
+    const filterSensitiveLog: (obj: StartContactRecordingResponse) => any;
+}
+
+export interface DestinationNotAllowedException extends __SmithyException, $MetadataBearer {
+    name: "DestinationNotAllowedException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace DestinationNotAllowedException {
+    
+    const filterSensitiveLog: (obj: DestinationNotAllowedException) => any;
+}
+
+export interface OutboundContactNotPermittedException extends __SmithyException, $MetadataBearer {
+    name: "OutboundContactNotPermittedException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace OutboundContactNotPermittedException {
+    
+    const filterSensitiveLog: (obj: OutboundContactNotPermittedException) => any;
+}
+
+export interface AnswerMachineDetectionConfig {
+    
+    EnableAnswerMachineDetection?: boolean;
+    
+    AwaitAnswerMachinePrompt?: boolean;
+}
+export declare namespace AnswerMachineDetectionConfig {
+    
+    const filterSensitiveLog: (obj: AnswerMachineDetectionConfig) => any;
+}
+export declare enum TrafficType {
+    CAMPAIGN = "CAMPAIGN",
+    GENERAL = "GENERAL"
+}
+export interface StartOutboundVoiceContactRequest {
+    
+    DestinationPhoneNumber: string | undefined;
+    
+    ContactFlowId: string | undefined;
+    
+    InstanceId: string | undefined;
+    
+    ClientToken?: string;
+    
+    SourcePhoneNumber?: string;
+    
+    QueueId?: string;
+    
+    Attributes?: {
+        [key: string]: string;
+    };
+    
+    AnswerMachineDetectionConfig?: AnswerMachineDetectionConfig;
+    
+    CampaignId?: string;
+    
+    TrafficType?: TrafficType | string;
+}
+export declare namespace StartOutboundVoiceContactRequest {
+    
+    const filterSensitiveLog: (obj: StartOutboundVoiceContactRequest) => any;
+}
+export interface StartOutboundVoiceContactResponse {
+    
+    ContactId?: string;
+}
+export declare namespace StartOutboundVoiceContactResponse {
+    
+    const filterSensitiveLog: (obj: StartOutboundVoiceContactResponse) => any;
+}
+export declare enum ReferenceType {
+    URL = "URL"
+}
+
+export interface Reference {
+    
+    Value: string | undefined;
+    
+    Type: ReferenceType | string | undefined;
+}
+export declare namespace Reference {
+    
+    const filterSensitiveLog: (obj: Reference) => any;
+}
+export interface StartTaskContactRequest {
+    
+    InstanceId: string | undefined;
+    
+    PreviousContactId?: string;
+    
+    ContactFlowId: string | undefined;
+    
+    Attributes?: {
+        [key: string]: string;
+    };
+    
+    Name: string | undefined;
+    
+    References?: {
+        [key: string]: Reference;
+    };
+    
+    Description?: string;
+    
+    ClientToken?: string;
+}
+export declare namespace StartTaskContactRequest {
+    
+    const filterSensitiveLog: (obj: StartTaskContactRequest) => any;
+}
+export interface StartTaskContactResponse {
+    
+    ContactId?: string;
+}
+export declare namespace StartTaskContactResponse {
+    
+    const filterSensitiveLog: (obj: StartTaskContactResponse) => any;
+}
+
+export interface ContactNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ContactNotFoundException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace ContactNotFoundException {
+    
+    const filterSensitiveLog: (obj: ContactNotFoundException) => any;
+}
+export interface StopContactRequest {
+    
+    ContactId: string | undefined;
+    
+    InstanceId: string | undefined;
+}
+export declare namespace StopContactRequest {
+    
+    const filterSensitiveLog: (obj: StopContactRequest) => any;
+}
+export interface StopContactResponse {
+}
+export declare namespace StopContactResponse {
+    
+    const filterSensitiveLog: (obj: StopContactResponse) => any;
+}
+export interface StopContactRecordingRequest {
+    
+    InstanceId: string | undefined;
+    
+    ContactId: string | undefined;
+    
+    InitialContactId: string | undefined;
+}
+export declare namespace StopContactRecordingRequest {
+    
+    const filterSensitiveLog: (obj: StopContactRecordingRequest) => any;
+}
+export interface StopContactRecordingResponse {
+}
+export declare namespace StopContactRecordingResponse {
+    
+    const filterSensitiveLog: (obj: StopContactRecordingResponse) => any;
+}
+export interface SuspendContactRecordingRequest {
+    
+    InstanceId: string | undefined;
+    
+    ContactId: string | undefined;
+    
+    InitialContactId: string | undefined;
+}
+export declare namespace SuspendContactRecordingRequest {
+    
+    const filterSensitiveLog: (obj: SuspendContactRecordingRequest) => any;
+}
+export interface SuspendContactRecordingResponse {
+}
+export declare namespace SuspendContactRecordingResponse {
+    
+    const filterSensitiveLog: (obj: SuspendContactRecordingResponse) => any;
+}
+export interface TagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tags: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface UntagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UpdateAgentStatusRequest {
+    
+    InstanceId: string | undefined;
+    
+    AgentStatusId: string | undefined;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    State?: AgentStatusState | string;
+    
+    DisplayOrder?: number;
+    
+    ResetOrderNumber?: boolean;
+}
+export declare namespace UpdateAgentStatusRequest {
+    
+    const filterSensitiveLog: (obj: UpdateAgentStatusRequest) => any;
+}
+export interface UpdateContactAttributesRequest {
+    
+    InitialContactId: string | undefined;
+    
+    InstanceId: string | undefined;
+    
+    Attributes: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace UpdateContactAttributesRequest {
+    
+    const filterSensitiveLog: (obj: UpdateContactAttributesRequest) => any;
+}
+export interface UpdateContactAttributesResponse {
+}
+export declare namespace UpdateContactAttributesResponse {
+    
+    const filterSensitiveLog: (obj: UpdateContactAttributesResponse) => any;
+}
+export interface UpdateContactFlowContentRequest {
+    
+    InstanceId: string | undefined;
+    
+    ContactFlowId: string | undefined;
+    
+    Content: string | undefined;
+}
+export declare namespace UpdateContactFlowContentRequest {
+    
+    const filterSensitiveLog: (obj: UpdateContactFlowContentRequest) => any;
+}
+export interface UpdateContactFlowNameRequest {
+    
+    InstanceId: string | undefined;
+    
+    ContactFlowId: string | undefined;
+    
+    Name?: string;
+    
+    Description?: string;
+}
+export declare namespace UpdateContactFlowNameRequest {
+    
+    const filterSensitiveLog: (obj: UpdateContactFlowNameRequest) => any;
+}
+export interface UpdateHoursOfOperationRequest {
+    
+    InstanceId: string | undefined;
+    
+    HoursOfOperationId: string | undefined;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    TimeZone?: string;
+    
+    Config?: HoursOfOperationConfig[];
+}
+export declare namespace UpdateHoursOfOperationRequest {
+    
+    const filterSensitiveLog: (obj: UpdateHoursOfOperationRequest) => any;
+}
+export interface UpdateInstanceAttributeRequest {
+    
+    InstanceId: string | undefined;
+    
+    AttributeType: InstanceAttributeType | string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace UpdateInstanceAttributeRequest {
+    
+    const filterSensitiveLog: (obj: UpdateInstanceAttributeRequest) => any;
+}
+export interface UpdateInstanceStorageConfigRequest {
+    
+    InstanceId: string | undefined;
+    
+    AssociationId: string | undefined;
+    
+    ResourceType: InstanceStorageResourceType | string | undefined;
+    
+    StorageConfig: InstanceStorageConfig | undefined;
+}
+export declare namespace UpdateInstanceStorageConfigRequest {
+    
+    const filterSensitiveLog: (obj: UpdateInstanceStorageConfigRequest) => any;
+}
+export interface UpdateQueueHoursOfOperationRequest {
+    
+    InstanceId: string | undefined;
+    
+    QueueId: string | undefined;
+    
+    HoursOfOperationId: string | undefined;
+}
+export declare namespace UpdateQueueHoursOfOperationRequest {
+    
+    const filterSensitiveLog: (obj: UpdateQueueHoursOfOperationRequest) => any;
+}
+export interface UpdateQueueMaxContactsRequest {
+    
+    InstanceId: string | undefined;
+    
+    QueueId: string | undefined;
+    
+    MaxContacts?: number;
+}
+export declare namespace UpdateQueueMaxContactsRequest {
+    
+    const filterSensitiveLog: (obj: UpdateQueueMaxContactsRequest) => any;
+}
+export interface UpdateQueueNameRequest {
+    
+    InstanceId: string | undefined;
+    
+    QueueId: string | undefined;
+    
+    Name?: string;
+    
+    Description?: string;
+}
+export declare namespace UpdateQueueNameRequest {
+    
+    const filterSensitiveLog: (obj: UpdateQueueNameRequest) => any;
+}
+export interface UpdateQueueOutboundCallerConfigRequest {
+    
+    InstanceId: string | undefined;
+    
+    QueueId: string | undefined;
+    
+    OutboundCallerConfig: OutboundCallerConfig | undefined;
+}
+export declare namespace UpdateQueueOutboundCallerConfigRequest {
+    
+    const filterSensitiveLog: (obj: UpdateQueueOutboundCallerConfigRequest) => any;
+}
+export interface UpdateQueueStatusRequest {
+    
+    InstanceId: string | undefined;
+    
+    QueueId: string | undefined;
+    
+    Status: QueueStatus | string | undefined;
+}
+export declare namespace UpdateQueueStatusRequest {
+    
+    const filterSensitiveLog: (obj: UpdateQueueStatusRequest) => any;
+}
+export interface UpdateQuickConnectConfigRequest {
+    
+    InstanceId: string | undefined;
+    
+    QuickConnectId: string | undefined;
+    
+    QuickConnectConfig: QuickConnectConfig | undefined;
+}
+export declare namespace UpdateQuickConnectConfigRequest {
+    
+    const filterSensitiveLog: (obj: UpdateQuickConnectConfigRequest) => any;
+}
+export interface UpdateQuickConnectNameRequest {
+    
+    InstanceId: string | undefined;
+    
+    QuickConnectId: string | undefined;
+    
+    Name?: string;
+    
+    Description?: string;
+}
+export declare namespace UpdateQuickConnectNameRequest {
+    
+    const filterSensitiveLog: (obj: UpdateQuickConnectNameRequest) => any;
+}
+export interface UpdateRoutingProfileConcurrencyRequest {
+    
+    InstanceId: string | undefined;
+    
+    RoutingProfileId: string | undefined;
+    
+    MediaConcurrencies: MediaConcurrency[] | undefined;
+}
+export declare namespace UpdateRoutingProfileConcurrencyRequest {
+    
+    const filterSensitiveLog: (obj: UpdateRoutingProfileConcurrencyRequest) => any;
+}
+export interface UpdateRoutingProfileDefaultOutboundQueueRequest {
+    
+    InstanceId: string | undefined;
+    
+    RoutingProfileId: string | undefined;
+    
+    DefaultOutboundQueueId: string | undefined;
+}
+export declare namespace UpdateRoutingProfileDefaultOutboundQueueRequest {
+    
+    const filterSensitiveLog: (obj: UpdateRoutingProfileDefaultOutboundQueueRequest) => any;
+}
+export interface UpdateRoutingProfileNameRequest {
+    
+    InstanceId: string | undefined;
+    
+    RoutingProfileId: string | undefined;
+    
+    Name?: string;
+    
+    Description?: string;
+}
+export declare namespace UpdateRoutingProfileNameRequest {
+    
+    const filterSensitiveLog: (obj: UpdateRoutingProfileNameRequest) => any;
+}
+export interface UpdateRoutingProfileQueuesRequest {
+    
+    InstanceId: string | undefined;
+    
+    RoutingProfileId: string | undefined;
+    
+    QueueConfigs: RoutingProfileQueueConfig[] | undefined;
+}
+export declare namespace UpdateRoutingProfileQueuesRequest {
+    
+    const filterSensitiveLog: (obj: UpdateRoutingProfileQueuesRequest) => any;
+}
+export interface UpdateUserHierarchyRequest {
+    
+    HierarchyGroupId?: string;
+    
+    UserId: string | undefined;
+    
+    InstanceId: string | undefined;
+}
+export declare namespace UpdateUserHierarchyRequest {
+    
+    const filterSensitiveLog: (obj: UpdateUserHierarchyRequest) => any;
+}
+export interface UpdateUserHierarchyGroupNameRequest {
+    
+    Name: string | undefined;
+    
+    HierarchyGroupId: string | undefined;
+    
+    InstanceId: string | undefined;
+}
+export declare namespace UpdateUserHierarchyGroupNameRequest {
+    
+    const filterSensitiveLog: (obj: UpdateUserHierarchyGroupNameRequest) => any;
+}
+
+export interface HierarchyLevelUpdate {
+    
+    Name: string | undefined;
+}
+export declare namespace HierarchyLevelUpdate {
+    
+    const filterSensitiveLog: (obj: HierarchyLevelUpdate) => any;
+}
+
+export interface HierarchyStructureUpdate {
+    
+    LevelOne?: HierarchyLevelUpdate;
+    
+    LevelTwo?: HierarchyLevelUpdate;
+    
+    LevelThree?: HierarchyLevelUpdate;
+    
+    LevelFour?: HierarchyLevelUpdate;
+    
+    LevelFive?: HierarchyLevelUpdate;
+}
+export declare namespace HierarchyStructureUpdate {
+    
+    const filterSensitiveLog: (obj: HierarchyStructureUpdate) => any;
+}
+export interface UpdateUserHierarchyStructureRequest {
+    
+    HierarchyStructure: HierarchyStructureUpdate | undefined;
+    
+    InstanceId: string | undefined;
+}
+export declare namespace UpdateUserHierarchyStructureRequest {
+    
+    const filterSensitiveLog: (obj: UpdateUserHierarchyStructureRequest) => any;
+}
+export interface UpdateUserIdentityInfoRequest {
+    
+    IdentityInfo: UserIdentityInfo | undefined;
+    
+    UserId: string | undefined;
+    
+    InstanceId: string | undefined;
+}
+export declare namespace UpdateUserIdentityInfoRequest {
+    
+    const filterSensitiveLog: (obj: UpdateUserIdentityInfoRequest) => any;
+}
+export interface UpdateUserPhoneConfigRequest {
+    
+    PhoneConfig: UserPhoneConfig | undefined;
+    
+    UserId: string | undefined;
+    
+    InstanceId: string | undefined;
+}
+export declare namespace UpdateUserPhoneConfigRequest {
+    
+    const filterSensitiveLog: (obj: UpdateUserPhoneConfigRequest) => any;
+}
+export interface UpdateUserRoutingProfileRequest {
+    
+    RoutingProfileId: string | undefined;
+    
+    UserId: string | undefined;
+    
+    InstanceId: string | undefined;
+}
+export declare namespace UpdateUserRoutingProfileRequest {
+    
+    const filterSensitiveLog: (obj: UpdateUserRoutingProfileRequest) => any;
+}
+export interface UpdateUserSecurityProfilesRequest {
+    
+    SecurityProfileIds: string[] | undefined;
+    
+    UserId: string | undefined;
+    
+    InstanceId: string | undefined;
+}
+export declare namespace UpdateUserSecurityProfilesRequest {
+    
+    const filterSensitiveLog: (obj: UpdateUserSecurityProfilesRequest) => any;
+}