@aws-sdk/client-chime 3.50.0 → 3.51.0

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

@@ -0,0 +1,3089 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+export declare enum ErrorCode {
+    AccessDenied = "AccessDenied",
+    BadRequest = "BadRequest",
+    Conflict = "Conflict",
+    Forbidden = "Forbidden",
+    NotFound = "NotFound",
+    PhoneNumberAssociationsExist = "PhoneNumberAssociationsExist",
+    PreconditionFailed = "PreconditionFailed",
+    ResourceLimitExceeded = "ResourceLimitExceeded",
+    ServiceFailure = "ServiceFailure",
+    ServiceUnavailable = "ServiceUnavailable",
+    Throttled = "Throttled",
+    Throttling = "Throttling",
+    Unauthorized = "Unauthorized",
+    Unprocessable = "Unprocessable",
+    VoiceConnectorGroupAssociationsExist = "VoiceConnectorGroupAssociationsExist"
+}
+
+export interface AccessDeniedException extends __SmithyException, $MetadataBearer {
+    name: "AccessDeniedException";
+    $fault: "client";
+    Code?: ErrorCode | string;
+    Message?: string;
+}
+export declare enum AccountStatus {
+    Active = "Active",
+    Suspended = "Suspended"
+}
+export declare enum AccountType {
+    EnterpriseDirectory = "EnterpriseDirectory",
+    EnterpriseLWA = "EnterpriseLWA",
+    EnterpriseOIDC = "EnterpriseOIDC",
+    Team = "Team"
+}
+export declare enum License {
+    Basic = "Basic",
+    Plus = "Plus",
+    Pro = "Pro",
+    ProTrial = "ProTrial"
+}
+
+export interface SigninDelegateGroup {
+    
+    GroupName?: string;
+}
+export declare namespace SigninDelegateGroup {
+    
+    const filterSensitiveLog: (obj: SigninDelegateGroup) => any;
+}
+
+export interface Account {
+    
+    AwsAccountId: string | undefined;
+    
+    AccountId: string | undefined;
+    
+    Name: string | undefined;
+    
+    AccountType?: AccountType | string;
+    
+    CreatedTimestamp?: Date;
+    
+    DefaultLicense?: License | string;
+    
+    SupportedLicenses?: (License | string)[];
+    
+    AccountStatus?: AccountStatus | string;
+    
+    SigninDelegateGroups?: SigninDelegateGroup[];
+}
+export declare namespace Account {
+    
+    const filterSensitiveLog: (obj: Account) => any;
+}
+
+export interface AccountSettings {
+    
+    DisableRemoteControl?: boolean;
+    
+    EnableDialOut?: boolean;
+}
+export declare namespace AccountSettings {
+    
+    const filterSensitiveLog: (obj: AccountSettings) => any;
+}
+
+export interface AlexaForBusinessMetadata {
+    
+    IsAlexaForBusinessEnabled?: boolean;
+    
+    AlexaForBusinessRoomArn?: string;
+}
+export declare namespace AlexaForBusinessMetadata {
+    
+    const filterSensitiveLog: (obj: AlexaForBusinessMetadata) => any;
+}
+
+export interface AppInstance {
+    
+    AppInstanceArn?: string;
+    
+    Name?: string;
+    
+    Metadata?: string;
+    
+    CreatedTimestamp?: Date;
+    
+    LastUpdatedTimestamp?: Date;
+}
+export declare namespace AppInstance {
+    
+    const filterSensitiveLog: (obj: AppInstance) => any;
+}
+
+export interface Identity {
+    
+    Arn?: string;
+    
+    Name?: string;
+}
+export declare namespace Identity {
+    
+    const filterSensitiveLog: (obj: Identity) => any;
+}
+
+export interface AppInstanceAdmin {
+    
+    Admin?: Identity;
+    
+    AppInstanceArn?: string;
+    
+    CreatedTimestamp?: Date;
+}
+export declare namespace AppInstanceAdmin {
+    
+    const filterSensitiveLog: (obj: AppInstanceAdmin) => any;
+}
+
+export interface AppInstanceAdminSummary {
+    
+    Admin?: Identity;
+}
+export declare namespace AppInstanceAdminSummary {
+    
+    const filterSensitiveLog: (obj: AppInstanceAdminSummary) => any;
+}
+export declare enum AppInstanceDataType {
+    Channel = "Channel",
+    ChannelMessage = "ChannelMessage"
+}
+
+export interface AppInstanceSummary {
+    
+    AppInstanceArn?: string;
+    
+    Name?: string;
+    
+    Metadata?: string;
+}
+export declare namespace AppInstanceSummary {
+    
+    const filterSensitiveLog: (obj: AppInstanceSummary) => any;
+}
+
+export interface ChannelRetentionSettings {
+    
+    RetentionDays?: number;
+}
+export declare namespace ChannelRetentionSettings {
+    
+    const filterSensitiveLog: (obj: ChannelRetentionSettings) => any;
+}
+
+export interface AppInstanceRetentionSettings {
+    
+    ChannelRetentionSettings?: ChannelRetentionSettings;
+}
+export declare namespace AppInstanceRetentionSettings {
+    
+    const filterSensitiveLog: (obj: AppInstanceRetentionSettings) => any;
+}
+
+export interface AppInstanceStreamingConfiguration {
+    
+    AppInstanceDataType: AppInstanceDataType | string | undefined;
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace AppInstanceStreamingConfiguration {
+    
+    const filterSensitiveLog: (obj: AppInstanceStreamingConfiguration) => any;
+}
+
+export interface AppInstanceUser {
+    
+    AppInstanceUserArn?: string;
+    
+    Name?: string;
+    
+    CreatedTimestamp?: Date;
+    
+    Metadata?: string;
+    
+    LastUpdatedTimestamp?: Date;
+}
+export declare namespace AppInstanceUser {
+    
+    const filterSensitiveLog: (obj: AppInstanceUser) => any;
+}
+
+export interface AppInstanceUserSummary {
+    
+    AppInstanceUserArn?: string;
+    
+    Name?: string;
+    
+    Metadata?: string;
+}
+export declare namespace AppInstanceUserSummary {
+    
+    const filterSensitiveLog: (obj: AppInstanceUserSummary) => any;
+}
+export declare enum ChannelMembershipType {
+    DEFAULT = "DEFAULT",
+    HIDDEN = "HIDDEN"
+}
+
+export interface AppInstanceUserMembershipSummary {
+    
+    Type?: ChannelMembershipType | string;
+    
+    ReadMarkerTimestamp?: Date;
+}
+export declare namespace AppInstanceUserMembershipSummary {
+    
+    const filterSensitiveLog: (obj: AppInstanceUserMembershipSummary) => any;
+}
+export declare enum AudioMuxType {
+    AudioOnly = "AudioOnly",
+    AudioWithActiveSpeakerVideo = "AudioWithActiveSpeakerVideo"
+}
+
+export interface AudioArtifactsConfiguration {
+    
+    MuxType: AudioMuxType | string | undefined;
+}
+export declare namespace AudioArtifactsConfiguration {
+    
+    const filterSensitiveLog: (obj: AudioArtifactsConfiguration) => any;
+}
+export declare enum ContentMuxType {
+    ContentOnly = "ContentOnly"
+}
+export declare enum ArtifactsState {
+    Disabled = "Disabled",
+    Enabled = "Enabled"
+}
+
+export interface ContentArtifactsConfiguration {
+    
+    State: ArtifactsState | string | undefined;
+    
+    MuxType?: ContentMuxType | string;
+}
+export declare namespace ContentArtifactsConfiguration {
+    
+    const filterSensitiveLog: (obj: ContentArtifactsConfiguration) => any;
+}
+export declare enum VideoMuxType {
+    VideoOnly = "VideoOnly"
+}
+
+export interface VideoArtifactsConfiguration {
+    
+    State: ArtifactsState | string | undefined;
+    
+    MuxType?: VideoMuxType | string;
+}
+export declare namespace VideoArtifactsConfiguration {
+    
+    const filterSensitiveLog: (obj: VideoArtifactsConfiguration) => any;
+}
+
+export interface ArtifactsConfiguration {
+    
+    Audio: AudioArtifactsConfiguration | undefined;
+    
+    Video: VideoArtifactsConfiguration | undefined;
+    
+    Content: ContentArtifactsConfiguration | undefined;
+}
+export declare namespace ArtifactsConfiguration {
+    
+    const filterSensitiveLog: (obj: ArtifactsConfiguration) => any;
+}
+export interface AssociatePhoneNumbersWithVoiceConnectorRequest {
+    
+    VoiceConnectorId: string | undefined;
+    
+    E164PhoneNumbers: string[] | undefined;
+    
+    ForceAssociate?: boolean;
+}
+export declare namespace AssociatePhoneNumbersWithVoiceConnectorRequest {
+    
+    const filterSensitiveLog: (obj: AssociatePhoneNumbersWithVoiceConnectorRequest) => any;
+}
+
+export interface PhoneNumberError {
+    
+    PhoneNumberId?: string;
+    
+    ErrorCode?: ErrorCode | string;
+    
+    ErrorMessage?: string;
+}
+export declare namespace PhoneNumberError {
+    
+    const filterSensitiveLog: (obj: PhoneNumberError) => any;
+}
+export interface AssociatePhoneNumbersWithVoiceConnectorResponse {
+    
+    PhoneNumberErrors?: PhoneNumberError[];
+}
+export declare namespace AssociatePhoneNumbersWithVoiceConnectorResponse {
+    
+    const filterSensitiveLog: (obj: AssociatePhoneNumbersWithVoiceConnectorResponse) => any;
+}
+
+export interface BadRequestException extends __SmithyException, $MetadataBearer {
+    name: "BadRequestException";
+    $fault: "client";
+    Code?: ErrorCode | string;
+    Message?: string;
+}
+
+export interface ForbiddenException extends __SmithyException, $MetadataBearer {
+    name: "ForbiddenException";
+    $fault: "client";
+    Code?: ErrorCode | string;
+    Message?: string;
+}
+
+export interface NotFoundException extends __SmithyException, $MetadataBearer {
+    name: "NotFoundException";
+    $fault: "client";
+    Code?: ErrorCode | string;
+    Message?: string;
+}
+
+export interface ServiceFailureException extends __SmithyException, $MetadataBearer {
+    name: "ServiceFailureException";
+    $fault: "server";
+    Code?: ErrorCode | string;
+    Message?: string;
+}
+
+export interface ServiceUnavailableException extends __SmithyException, $MetadataBearer {
+    name: "ServiceUnavailableException";
+    $fault: "server";
+    Code?: ErrorCode | string;
+    Message?: string;
+}
+
+export interface ThrottledClientException extends __SmithyException, $MetadataBearer {
+    name: "ThrottledClientException";
+    $fault: "client";
+    Code?: ErrorCode | string;
+    Message?: string;
+}
+
+export interface UnauthorizedClientException extends __SmithyException, $MetadataBearer {
+    name: "UnauthorizedClientException";
+    $fault: "client";
+    Code?: ErrorCode | string;
+    Message?: string;
+}
+export interface AssociatePhoneNumbersWithVoiceConnectorGroupRequest {
+    
+    VoiceConnectorGroupId: string | undefined;
+    
+    E164PhoneNumbers: string[] | undefined;
+    
+    ForceAssociate?: boolean;
+}
+export declare namespace AssociatePhoneNumbersWithVoiceConnectorGroupRequest {
+    
+    const filterSensitiveLog: (obj: AssociatePhoneNumbersWithVoiceConnectorGroupRequest) => any;
+}
+export interface AssociatePhoneNumbersWithVoiceConnectorGroupResponse {
+    
+    PhoneNumberErrors?: PhoneNumberError[];
+}
+export declare namespace AssociatePhoneNumbersWithVoiceConnectorGroupResponse {
+    
+    const filterSensitiveLog: (obj: AssociatePhoneNumbersWithVoiceConnectorGroupResponse) => any;
+}
+export interface AssociatePhoneNumberWithUserRequest {
+    
+    AccountId: string | undefined;
+    
+    UserId: string | undefined;
+    
+    E164PhoneNumber: string | undefined;
+}
+export declare namespace AssociatePhoneNumberWithUserRequest {
+    
+    const filterSensitiveLog: (obj: AssociatePhoneNumberWithUserRequest) => any;
+}
+export interface AssociatePhoneNumberWithUserResponse {
+}
+export declare namespace AssociatePhoneNumberWithUserResponse {
+    
+    const filterSensitiveLog: (obj: AssociatePhoneNumberWithUserResponse) => any;
+}
+export interface AssociateSigninDelegateGroupsWithAccountRequest {
+    
+    AccountId: string | undefined;
+    
+    SigninDelegateGroups: SigninDelegateGroup[] | undefined;
+}
+export declare namespace AssociateSigninDelegateGroupsWithAccountRequest {
+    
+    const filterSensitiveLog: (obj: AssociateSigninDelegateGroupsWithAccountRequest) => any;
+}
+export interface AssociateSigninDelegateGroupsWithAccountResponse {
+}
+export declare namespace AssociateSigninDelegateGroupsWithAccountResponse {
+    
+    const filterSensitiveLog: (obj: AssociateSigninDelegateGroupsWithAccountResponse) => any;
+}
+
+export interface Attendee {
+    
+    ExternalUserId?: string;
+    
+    AttendeeId?: string;
+    
+    JoinToken?: string;
+}
+export declare namespace Attendee {
+    
+    const filterSensitiveLog: (obj: Attendee) => any;
+}
+
+export interface Tag {
+    
+    Key: string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+
+export interface BatchChannelMemberships {
+    
+    InvitedBy?: Identity;
+    
+    Type?: ChannelMembershipType | string;
+    
+    Members?: Identity[];
+    
+    ChannelArn?: string;
+}
+export declare namespace BatchChannelMemberships {
+    
+    const filterSensitiveLog: (obj: BatchChannelMemberships) => any;
+}
+
+export interface CreateAttendeeRequestItem {
+    
+    ExternalUserId: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateAttendeeRequestItem {
+    
+    const filterSensitiveLog: (obj: CreateAttendeeRequestItem) => any;
+}
+export interface BatchCreateAttendeeRequest {
+    
+    MeetingId: string | undefined;
+    
+    Attendees: CreateAttendeeRequestItem[] | undefined;
+}
+export declare namespace BatchCreateAttendeeRequest {
+    
+    const filterSensitiveLog: (obj: BatchCreateAttendeeRequest) => any;
+}
+
+export interface CreateAttendeeError {
+    
+    ExternalUserId?: string;
+    
+    ErrorCode?: string;
+    
+    ErrorMessage?: string;
+}
+export declare namespace CreateAttendeeError {
+    
+    const filterSensitiveLog: (obj: CreateAttendeeError) => any;
+}
+export interface BatchCreateAttendeeResponse {
+    
+    Attendees?: Attendee[];
+    
+    Errors?: CreateAttendeeError[];
+}
+export declare namespace BatchCreateAttendeeResponse {
+    
+    const filterSensitiveLog: (obj: BatchCreateAttendeeResponse) => any;
+}
+
+export interface ResourceLimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "ResourceLimitExceededException";
+    $fault: "client";
+    Code?: ErrorCode | string;
+    Message?: string;
+}
+export interface BatchCreateChannelMembershipRequest {
+    
+    ChannelArn: string | undefined;
+    
+    Type?: ChannelMembershipType | string;
+    
+    MemberArns: string[] | undefined;
+    
+    ChimeBearer?: string;
+}
+export declare namespace BatchCreateChannelMembershipRequest {
+    
+    const filterSensitiveLog: (obj: BatchCreateChannelMembershipRequest) => any;
+}
+
+export interface BatchCreateChannelMembershipError {
+    
+    MemberArn?: string;
+    
+    ErrorCode?: ErrorCode | string;
+    
+    ErrorMessage?: string;
+}
+export declare namespace BatchCreateChannelMembershipError {
+    
+    const filterSensitiveLog: (obj: BatchCreateChannelMembershipError) => any;
+}
+export interface BatchCreateChannelMembershipResponse {
+    
+    BatchChannelMemberships?: BatchChannelMemberships;
+    
+    Errors?: BatchCreateChannelMembershipError[];
+}
+export declare namespace BatchCreateChannelMembershipResponse {
+    
+    const filterSensitiveLog: (obj: BatchCreateChannelMembershipResponse) => any;
+}
+export declare enum RoomMembershipRole {
+    Administrator = "Administrator",
+    Member = "Member"
+}
+
+export interface MembershipItem {
+    
+    MemberId?: string;
+    
+    Role?: RoomMembershipRole | string;
+}
+export declare namespace MembershipItem {
+    
+    const filterSensitiveLog: (obj: MembershipItem) => any;
+}
+export interface BatchCreateRoomMembershipRequest {
+    
+    AccountId: string | undefined;
+    
+    RoomId: string | undefined;
+    
+    MembershipItemList: MembershipItem[] | undefined;
+}
+export declare namespace BatchCreateRoomMembershipRequest {
+    
+    const filterSensitiveLog: (obj: BatchCreateRoomMembershipRequest) => any;
+}
+
+export interface MemberError {
+    
+    MemberId?: string;
+    
+    ErrorCode?: ErrorCode | string;
+    
+    ErrorMessage?: string;
+}
+export declare namespace MemberError {
+    
+    const filterSensitiveLog: (obj: MemberError) => any;
+}
+export interface BatchCreateRoomMembershipResponse {
+    
+    Errors?: MemberError[];
+}
+export declare namespace BatchCreateRoomMembershipResponse {
+    
+    const filterSensitiveLog: (obj: BatchCreateRoomMembershipResponse) => any;
+}
+export interface BatchDeletePhoneNumberRequest {
+    
+    PhoneNumberIds: string[] | undefined;
+}
+export declare namespace BatchDeletePhoneNumberRequest {
+    
+    const filterSensitiveLog: (obj: BatchDeletePhoneNumberRequest) => any;
+}
+export interface BatchDeletePhoneNumberResponse {
+    
+    PhoneNumberErrors?: PhoneNumberError[];
+}
+export declare namespace BatchDeletePhoneNumberResponse {
+    
+    const filterSensitiveLog: (obj: BatchDeletePhoneNumberResponse) => any;
+}
+export interface BatchSuspendUserRequest {
+    
+    AccountId: string | undefined;
+    
+    UserIdList: string[] | undefined;
+}
+export declare namespace BatchSuspendUserRequest {
+    
+    const filterSensitiveLog: (obj: BatchSuspendUserRequest) => any;
+}
+
+export interface UserError {
+    
+    UserId?: string;
+    
+    ErrorCode?: ErrorCode | string;
+    
+    ErrorMessage?: string;
+}
+export declare namespace UserError {
+    
+    const filterSensitiveLog: (obj: UserError) => any;
+}
+export interface BatchSuspendUserResponse {
+    
+    UserErrors?: UserError[];
+}
+export declare namespace BatchSuspendUserResponse {
+    
+    const filterSensitiveLog: (obj: BatchSuspendUserResponse) => any;
+}
+export interface BatchUnsuspendUserRequest {
+    
+    AccountId: string | undefined;
+    
+    UserIdList: string[] | undefined;
+}
+export declare namespace BatchUnsuspendUserRequest {
+    
+    const filterSensitiveLog: (obj: BatchUnsuspendUserRequest) => any;
+}
+export interface BatchUnsuspendUserResponse {
+    
+    UserErrors?: UserError[];
+}
+export declare namespace BatchUnsuspendUserResponse {
+    
+    const filterSensitiveLog: (obj: BatchUnsuspendUserResponse) => any;
+}
+export declare enum PhoneNumberProductType {
+    BusinessCalling = "BusinessCalling",
+    SipMediaApplicationDialIn = "SipMediaApplicationDialIn",
+    VoiceConnector = "VoiceConnector"
+}
+
+export interface UpdatePhoneNumberRequestItem {
+    
+    PhoneNumberId: string | undefined;
+    
+    ProductType?: PhoneNumberProductType | string;
+    
+    CallingName?: string;
+}
+export declare namespace UpdatePhoneNumberRequestItem {
+    
+    const filterSensitiveLog: (obj: UpdatePhoneNumberRequestItem) => any;
+}
+export interface BatchUpdatePhoneNumberRequest {
+    
+    UpdatePhoneNumberRequestItems: UpdatePhoneNumberRequestItem[] | undefined;
+}
+export declare namespace BatchUpdatePhoneNumberRequest {
+    
+    const filterSensitiveLog: (obj: BatchUpdatePhoneNumberRequest) => any;
+}
+export interface BatchUpdatePhoneNumberResponse {
+    
+    PhoneNumberErrors?: PhoneNumberError[];
+}
+export declare namespace BatchUpdatePhoneNumberResponse {
+    
+    const filterSensitiveLog: (obj: BatchUpdatePhoneNumberResponse) => any;
+}
+export declare enum UserType {
+    PrivateUser = "PrivateUser",
+    SharedDevice = "SharedDevice"
+}
+
+export interface UpdateUserRequestItem {
+    
+    UserId: string | undefined;
+    
+    LicenseType?: License | string;
+    
+    UserType?: UserType | string;
+    
+    AlexaForBusinessMetadata?: AlexaForBusinessMetadata;
+}
+export declare namespace UpdateUserRequestItem {
+    
+    const filterSensitiveLog: (obj: UpdateUserRequestItem) => any;
+}
+export interface BatchUpdateUserRequest {
+    
+    AccountId: string | undefined;
+    
+    UpdateUserRequestItems: UpdateUserRequestItem[] | undefined;
+}
+export declare namespace BatchUpdateUserRequest {
+    
+    const filterSensitiveLog: (obj: BatchUpdateUserRequest) => any;
+}
+export interface BatchUpdateUserResponse {
+    
+    UserErrors?: UserError[];
+}
+export declare namespace BatchUpdateUserResponse {
+    
+    const filterSensitiveLog: (obj: BatchUpdateUserResponse) => any;
+}
+export declare enum BotType {
+    ChatBot = "ChatBot"
+}
+
+export interface Bot {
+    
+    BotId?: string;
+    
+    UserId?: string;
+    
+    DisplayName?: string;
+    
+    BotType?: BotType | string;
+    
+    Disabled?: boolean;
+    
+    CreatedTimestamp?: Date;
+    
+    UpdatedTimestamp?: Date;
+    
+    BotEmail?: string;
+    
+    SecurityToken?: string;
+}
+export declare namespace Bot {
+    
+    const filterSensitiveLog: (obj: Bot) => any;
+}
+
+export interface BusinessCallingSettings {
+    
+    CdrBucket?: string;
+}
+export declare namespace BusinessCallingSettings {
+    
+    const filterSensitiveLog: (obj: BusinessCallingSettings) => any;
+}
+export declare enum CallingNameStatus {
+    Unassigned = "Unassigned",
+    UpdateFailed = "UpdateFailed",
+    UpdateInProgress = "UpdateInProgress",
+    UpdateSucceeded = "UpdateSucceeded"
+}
+export declare enum Capability {
+    SMS = "SMS",
+    Voice = "Voice"
+}
+export declare enum ChannelMode {
+    RESTRICTED = "RESTRICTED",
+    UNRESTRICTED = "UNRESTRICTED"
+}
+export declare enum ChannelPrivacy {
+    PRIVATE = "PRIVATE",
+    PUBLIC = "PUBLIC"
+}
+
+export interface Channel {
+    
+    Name?: string;
+    
+    ChannelArn?: string;
+    
+    Mode?: ChannelMode | string;
+    
+    Privacy?: ChannelPrivacy | string;
+    
+    Metadata?: string;
+    
+    CreatedBy?: Identity;
+    
+    CreatedTimestamp?: Date;
+    
+    LastMessageTimestamp?: Date;
+    
+    LastUpdatedTimestamp?: Date;
+}
+export declare namespace Channel {
+    
+    const filterSensitiveLog: (obj: Channel) => any;
+}
+
+export interface ChannelBan {
+    
+    Member?: Identity;
+    
+    ChannelArn?: string;
+    
+    CreatedTimestamp?: Date;
+    
+    CreatedBy?: Identity;
+}
+export declare namespace ChannelBan {
+    
+    const filterSensitiveLog: (obj: ChannelBan) => any;
+}
+
+export interface ChannelBanSummary {
+    
+    Member?: Identity;
+}
+export declare namespace ChannelBanSummary {
+    
+    const filterSensitiveLog: (obj: ChannelBanSummary) => any;
+}
+
+export interface ChannelMembership {
+    
+    InvitedBy?: Identity;
+    
+    Type?: ChannelMembershipType | string;
+    
+    Member?: Identity;
+    
+    ChannelArn?: string;
+    
+    CreatedTimestamp?: Date;
+    
+    LastUpdatedTimestamp?: Date;
+}
+export declare namespace ChannelMembership {
+    
+    const filterSensitiveLog: (obj: ChannelMembership) => any;
+}
+
+export interface ChannelSummary {
+    
+    Name?: string;
+    
+    ChannelArn?: string;
+    
+    Mode?: ChannelMode | string;
+    
+    Privacy?: ChannelPrivacy | string;
+    
+    Metadata?: string;
+    
+    LastMessageTimestamp?: Date;
+}
+export declare namespace ChannelSummary {
+    
+    const filterSensitiveLog: (obj: ChannelSummary) => any;
+}
+
+export interface ChannelMembershipForAppInstanceUserSummary {
+    
+    ChannelSummary?: ChannelSummary;
+    
+    AppInstanceUserMembershipSummary?: AppInstanceUserMembershipSummary;
+}
+export declare namespace ChannelMembershipForAppInstanceUserSummary {
+    
+    const filterSensitiveLog: (obj: ChannelMembershipForAppInstanceUserSummary) => any;
+}
+
+export interface ChannelMembershipSummary {
+    
+    Member?: Identity;
+}
+export declare namespace ChannelMembershipSummary {
+    
+    const filterSensitiveLog: (obj: ChannelMembershipSummary) => any;
+}
+export declare enum ChannelMessagePersistenceType {
+    NON_PERSISTENT = "NON_PERSISTENT",
+    PERSISTENT = "PERSISTENT"
+}
+export declare enum ChannelMessageType {
+    CONTROL = "CONTROL",
+    STANDARD = "STANDARD"
+}
+
+export interface ChannelMessage {
+    
+    ChannelArn?: string;
+    
+    MessageId?: string;
+    
+    Content?: string;
+    
+    Metadata?: string;
+    
+    Type?: ChannelMessageType | string;
+    
+    CreatedTimestamp?: Date;
+    
+    LastEditedTimestamp?: Date;
+    
+    LastUpdatedTimestamp?: Date;
+    
+    Sender?: Identity;
+    
+    Redacted?: boolean;
+    
+    Persistence?: ChannelMessagePersistenceType | string;
+}
+export declare namespace ChannelMessage {
+    
+    const filterSensitiveLog: (obj: ChannelMessage) => any;
+}
+
+export interface ChannelMessageSummary {
+    
+    MessageId?: string;
+    
+    Content?: string;
+    
+    Metadata?: string;
+    
+    Type?: ChannelMessageType | string;
+    
+    CreatedTimestamp?: Date;
+    
+    LastUpdatedTimestamp?: Date;
+    
+    LastEditedTimestamp?: Date;
+    
+    Sender?: Identity;
+    
+    Redacted?: boolean;
+}
+export declare namespace ChannelMessageSummary {
+    
+    const filterSensitiveLog: (obj: ChannelMessageSummary) => any;
+}
+
+export interface ChannelModeratedByAppInstanceUserSummary {
+    
+    ChannelSummary?: ChannelSummary;
+}
+export declare namespace ChannelModeratedByAppInstanceUserSummary {
+    
+    const filterSensitiveLog: (obj: ChannelModeratedByAppInstanceUserSummary) => any;
+}
+
+export interface ChannelModerator {
+    
+    Moderator?: Identity;
+    
+    ChannelArn?: string;
+    
+    CreatedTimestamp?: Date;
+    
+    CreatedBy?: Identity;
+}
+export declare namespace ChannelModerator {
+    
+    const filterSensitiveLog: (obj: ChannelModerator) => any;
+}
+
+export interface ChannelModeratorSummary {
+    
+    Moderator?: Identity;
+}
+export declare namespace ChannelModeratorSummary {
+    
+    const filterSensitiveLog: (obj: ChannelModeratorSummary) => any;
+}
+
+export interface SelectedVideoStreams {
+    
+    AttendeeIds?: string[];
+    
+    ExternalUserIds?: string[];
+}
+export declare namespace SelectedVideoStreams {
+    
+    const filterSensitiveLog: (obj: SelectedVideoStreams) => any;
+}
+
+export interface SourceConfiguration {
+    
+    SelectedVideoStreams?: SelectedVideoStreams;
+}
+export declare namespace SourceConfiguration {
+    
+    const filterSensitiveLog: (obj: SourceConfiguration) => any;
+}
+
+export interface ChimeSdkMeetingConfiguration {
+    
+    SourceConfiguration?: SourceConfiguration;
+    
+    ArtifactsConfiguration?: ArtifactsConfiguration;
+}
+export declare namespace ChimeSdkMeetingConfiguration {
+    
+    const filterSensitiveLog: (obj: ChimeSdkMeetingConfiguration) => any;
+}
+
+export interface ConflictException extends __SmithyException, $MetadataBearer {
+    name: "ConflictException";
+    $fault: "client";
+    Code?: ErrorCode | string;
+    Message?: string;
+}
+
+export interface ConversationRetentionSettings {
+    
+    RetentionDays?: number;
+}
+export declare namespace ConversationRetentionSettings {
+    
+    const filterSensitiveLog: (obj: ConversationRetentionSettings) => any;
+}
+export interface CreateAccountRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace CreateAccountRequest {
+    
+    const filterSensitiveLog: (obj: CreateAccountRequest) => any;
+}
+export interface CreateAccountResponse {
+    
+    Account?: Account;
+}
+export declare namespace CreateAccountResponse {
+    
+    const filterSensitiveLog: (obj: CreateAccountResponse) => any;
+}
+export interface CreateAppInstanceRequest {
+    
+    Name: string | undefined;
+    
+    Metadata?: string;
+    
+    ClientRequestToken?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateAppInstanceRequest {
+    
+    const filterSensitiveLog: (obj: CreateAppInstanceRequest) => any;
+}
+export interface CreateAppInstanceResponse {
+    
+    AppInstanceArn?: string;
+}
+export declare namespace CreateAppInstanceResponse {
+    
+    const filterSensitiveLog: (obj: CreateAppInstanceResponse) => any;
+}
+export interface CreateAppInstanceAdminRequest {
+    
+    AppInstanceAdminArn: string | undefined;
+    
+    AppInstanceArn: string | undefined;
+}
+export declare namespace CreateAppInstanceAdminRequest {
+    
+    const filterSensitiveLog: (obj: CreateAppInstanceAdminRequest) => any;
+}
+export interface CreateAppInstanceAdminResponse {
+    
+    AppInstanceAdmin?: Identity;
+    
+    AppInstanceArn?: string;
+}
+export declare namespace CreateAppInstanceAdminResponse {
+    
+    const filterSensitiveLog: (obj: CreateAppInstanceAdminResponse) => any;
+}
+export interface CreateAppInstanceUserRequest {
+    
+    AppInstanceArn: string | undefined;
+    
+    AppInstanceUserId: string | undefined;
+    
+    Name: string | undefined;
+    
+    Metadata?: string;
+    
+    ClientRequestToken?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateAppInstanceUserRequest {
+    
+    const filterSensitiveLog: (obj: CreateAppInstanceUserRequest) => any;
+}
+export interface CreateAppInstanceUserResponse {
+    
+    AppInstanceUserArn?: string;
+}
+export declare namespace CreateAppInstanceUserResponse {
+    
+    const filterSensitiveLog: (obj: CreateAppInstanceUserResponse) => any;
+}
+export interface CreateAttendeeRequest {
+    
+    MeetingId: string | undefined;
+    
+    ExternalUserId: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateAttendeeRequest {
+    
+    const filterSensitiveLog: (obj: CreateAttendeeRequest) => any;
+}
+export interface CreateAttendeeResponse {
+    
+    Attendee?: Attendee;
+}
+export declare namespace CreateAttendeeResponse {
+    
+    const filterSensitiveLog: (obj: CreateAttendeeResponse) => any;
+}
+export interface CreateBotRequest {
+    
+    AccountId: string | undefined;
+    
+    DisplayName: string | undefined;
+    
+    Domain?: string;
+}
+export declare namespace CreateBotRequest {
+    
+    const filterSensitiveLog: (obj: CreateBotRequest) => any;
+}
+export interface CreateBotResponse {
+    
+    Bot?: Bot;
+}
+export declare namespace CreateBotResponse {
+    
+    const filterSensitiveLog: (obj: CreateBotResponse) => any;
+}
+export interface CreateChannelRequest {
+    
+    AppInstanceArn: string | undefined;
+    
+    Name: string | undefined;
+    
+    Mode?: ChannelMode | string;
+    
+    Privacy?: ChannelPrivacy | string;
+    
+    Metadata?: string;
+    
+    ClientRequestToken?: string;
+    
+    Tags?: Tag[];
+    
+    ChimeBearer?: string;
+}
+export declare namespace CreateChannelRequest {
+    
+    const filterSensitiveLog: (obj: CreateChannelRequest) => any;
+}
+export interface CreateChannelResponse {
+    
+    ChannelArn?: string;
+}
+export declare namespace CreateChannelResponse {
+    
+    const filterSensitiveLog: (obj: CreateChannelResponse) => any;
+}
+export interface CreateChannelBanRequest {
+    
+    ChannelArn: string | undefined;
+    
+    MemberArn: string | undefined;
+    
+    ChimeBearer?: string;
+}
+export declare namespace CreateChannelBanRequest {
+    
+    const filterSensitiveLog: (obj: CreateChannelBanRequest) => any;
+}
+export interface CreateChannelBanResponse {
+    
+    ChannelArn?: string;
+    
+    Member?: Identity;
+}
+export declare namespace CreateChannelBanResponse {
+    
+    const filterSensitiveLog: (obj: CreateChannelBanResponse) => any;
+}
+export interface CreateChannelMembershipRequest {
+    
+    ChannelArn: string | undefined;
+    
+    MemberArn: string | undefined;
+    
+    Type: ChannelMembershipType | string | undefined;
+    
+    ChimeBearer?: string;
+}
+export declare namespace CreateChannelMembershipRequest {
+    
+    const filterSensitiveLog: (obj: CreateChannelMembershipRequest) => any;
+}
+export interface CreateChannelMembershipResponse {
+    
+    ChannelArn?: string;
+    
+    Member?: Identity;
+}
+export declare namespace CreateChannelMembershipResponse {
+    
+    const filterSensitiveLog: (obj: CreateChannelMembershipResponse) => any;
+}
+export interface CreateChannelModeratorRequest {
+    
+    ChannelArn: string | undefined;
+    
+    ChannelModeratorArn: string | undefined;
+    
+    ChimeBearer?: string;
+}
+export declare namespace CreateChannelModeratorRequest {
+    
+    const filterSensitiveLog: (obj: CreateChannelModeratorRequest) => any;
+}
+export interface CreateChannelModeratorResponse {
+    
+    ChannelArn?: string;
+    
+    ChannelModerator?: Identity;
+}
+export declare namespace CreateChannelModeratorResponse {
+    
+    const filterSensitiveLog: (obj: CreateChannelModeratorResponse) => any;
+}
+export declare enum MediaPipelineSinkType {
+    S3Bucket = "S3Bucket"
+}
+export declare enum MediaPipelineSourceType {
+    ChimeSdkMeeting = "ChimeSdkMeeting"
+}
+export interface CreateMediaCapturePipelineRequest {
+    
+    SourceType: MediaPipelineSourceType | string | undefined;
+    
+    SourceArn: string | undefined;
+    
+    SinkType: MediaPipelineSinkType | string | undefined;
+    
+    SinkArn: string | undefined;
+    
+    ClientRequestToken?: string;
+    
+    ChimeSdkMeetingConfiguration?: ChimeSdkMeetingConfiguration;
+}
+export declare namespace CreateMediaCapturePipelineRequest {
+    
+    const filterSensitiveLog: (obj: CreateMediaCapturePipelineRequest) => any;
+}
+export declare enum MediaPipelineStatus {
+    Failed = "Failed",
+    InProgress = "InProgress",
+    Initializing = "Initializing",
+    Stopped = "Stopped",
+    Stopping = "Stopping"
+}
+
+export interface MediaCapturePipeline {
+    
+    MediaPipelineId?: string;
+    
+    SourceType?: MediaPipelineSourceType | string;
+    
+    SourceArn?: string;
+    
+    Status?: MediaPipelineStatus | string;
+    
+    SinkType?: MediaPipelineSinkType | string;
+    
+    SinkArn?: string;
+    
+    CreatedTimestamp?: Date;
+    
+    UpdatedTimestamp?: Date;
+    
+    ChimeSdkMeetingConfiguration?: ChimeSdkMeetingConfiguration;
+}
+export declare namespace MediaCapturePipeline {
+    
+    const filterSensitiveLog: (obj: MediaCapturePipeline) => any;
+}
+export interface CreateMediaCapturePipelineResponse {
+    
+    MediaCapturePipeline?: MediaCapturePipeline;
+}
+export declare namespace CreateMediaCapturePipelineResponse {
+    
+    const filterSensitiveLog: (obj: CreateMediaCapturePipelineResponse) => any;
+}
+
+export interface MeetingNotificationConfiguration {
+    
+    SnsTopicArn?: string;
+    
+    SqsQueueArn?: string;
+}
+export declare namespace MeetingNotificationConfiguration {
+    
+    const filterSensitiveLog: (obj: MeetingNotificationConfiguration) => any;
+}
+export interface CreateMeetingRequest {
+    
+    ClientRequestToken?: string;
+    
+    ExternalMeetingId?: string;
+    
+    MeetingHostId?: string;
+    
+    MediaRegion?: string;
+    
+    Tags?: Tag[];
+    
+    NotificationsConfiguration?: MeetingNotificationConfiguration;
+}
+export declare namespace CreateMeetingRequest {
+    
+    const filterSensitiveLog: (obj: CreateMeetingRequest) => any;
+}
+
+export interface MediaPlacement {
+    
+    AudioHostUrl?: string;
+    
+    AudioFallbackUrl?: string;
+    
+    ScreenDataUrl?: string;
+    
+    ScreenSharingUrl?: string;
+    
+    ScreenViewingUrl?: string;
+    
+    SignalingUrl?: string;
+    
+    TurnControlUrl?: string;
+    
+    EventIngestionUrl?: string;
+}
+export declare namespace MediaPlacement {
+    
+    const filterSensitiveLog: (obj: MediaPlacement) => any;
+}
+
+export interface Meeting {
+    
+    MeetingId?: string;
+    
+    ExternalMeetingId?: string;
+    
+    MediaPlacement?: MediaPlacement;
+    
+    MediaRegion?: string;
+}
+export declare namespace Meeting {
+    
+    const filterSensitiveLog: (obj: Meeting) => any;
+}
+export interface CreateMeetingResponse {
+    
+    Meeting?: Meeting;
+}
+export declare namespace CreateMeetingResponse {
+    
+    const filterSensitiveLog: (obj: CreateMeetingResponse) => any;
+}
+export interface CreateMeetingDialOutRequest {
+    
+    MeetingId: string | undefined;
+    
+    FromPhoneNumber: string | undefined;
+    
+    ToPhoneNumber: string | undefined;
+    
+    JoinToken: string | undefined;
+}
+export declare namespace CreateMeetingDialOutRequest {
+    
+    const filterSensitiveLog: (obj: CreateMeetingDialOutRequest) => any;
+}
+export interface CreateMeetingDialOutResponse {
+    
+    TransactionId?: string;
+}
+export declare namespace CreateMeetingDialOutResponse {
+    
+    const filterSensitiveLog: (obj: CreateMeetingDialOutResponse) => any;
+}
+export interface CreateMeetingWithAttendeesRequest {
+    
+    ClientRequestToken?: string;
+    
+    ExternalMeetingId?: string;
+    
+    MeetingHostId?: string;
+    
+    MediaRegion?: string;
+    
+    Tags?: Tag[];
+    
+    NotificationsConfiguration?: MeetingNotificationConfiguration;
+    
+    Attendees?: CreateAttendeeRequestItem[];
+}
+export declare namespace CreateMeetingWithAttendeesRequest {
+    
+    const filterSensitiveLog: (obj: CreateMeetingWithAttendeesRequest) => any;
+}
+export interface CreateMeetingWithAttendeesResponse {
+    
+    Meeting?: Meeting;
+    
+    Attendees?: Attendee[];
+    
+    Errors?: CreateAttendeeError[];
+}
+export declare namespace CreateMeetingWithAttendeesResponse {
+    
+    const filterSensitiveLog: (obj: CreateMeetingWithAttendeesResponse) => any;
+}
+export interface CreatePhoneNumberOrderRequest {
+    
+    ProductType: PhoneNumberProductType | string | undefined;
+    
+    E164PhoneNumbers: string[] | undefined;
+}
+export declare namespace CreatePhoneNumberOrderRequest {
+    
+    const filterSensitiveLog: (obj: CreatePhoneNumberOrderRequest) => any;
+}
+export declare enum OrderedPhoneNumberStatus {
+    Acquired = "Acquired",
+    Failed = "Failed",
+    Processing = "Processing"
+}
+
+export interface OrderedPhoneNumber {
+    
+    E164PhoneNumber?: string;
+    
+    Status?: OrderedPhoneNumberStatus | string;
+}
+export declare namespace OrderedPhoneNumber {
+    
+    const filterSensitiveLog: (obj: OrderedPhoneNumber) => any;
+}
+export declare enum PhoneNumberOrderStatus {
+    Failed = "Failed",
+    Partial = "Partial",
+    Processing = "Processing",
+    Successful = "Successful"
+}
+
+export interface PhoneNumberOrder {
+    
+    PhoneNumberOrderId?: string;
+    
+    ProductType?: PhoneNumberProductType | string;
+    
+    Status?: PhoneNumberOrderStatus | string;
+    
+    OrderedPhoneNumbers?: OrderedPhoneNumber[];
+    
+    CreatedTimestamp?: Date;
+    
+    UpdatedTimestamp?: Date;
+}
+export declare namespace PhoneNumberOrder {
+    
+    const filterSensitiveLog: (obj: PhoneNumberOrder) => any;
+}
+export interface CreatePhoneNumberOrderResponse {
+    
+    PhoneNumberOrder?: PhoneNumberOrder;
+}
+export declare namespace CreatePhoneNumberOrderResponse {
+    
+    const filterSensitiveLog: (obj: CreatePhoneNumberOrderResponse) => any;
+}
+export declare enum GeoMatchLevel {
+    AreaCode = "AreaCode",
+    Country = "Country"
+}
+
+export interface GeoMatchParams {
+    
+    Country: string | undefined;
+    
+    AreaCode: string | undefined;
+}
+export declare namespace GeoMatchParams {
+    
+    const filterSensitiveLog: (obj: GeoMatchParams) => any;
+}
+export declare enum NumberSelectionBehavior {
+    AvoidSticky = "AvoidSticky",
+    PreferSticky = "PreferSticky"
+}
+export interface CreateProxySessionRequest {
+    
+    VoiceConnectorId: string | undefined;
+    
+    ParticipantPhoneNumbers: string[] | undefined;
+    
+    Name?: string;
+    
+    ExpiryMinutes?: number;
+    
+    Capabilities: (Capability | string)[] | undefined;
+    
+    NumberSelectionBehavior?: NumberSelectionBehavior | string;
+    
+    GeoMatchLevel?: GeoMatchLevel | string;
+    
+    GeoMatchParams?: GeoMatchParams;
+}
+export declare namespace CreateProxySessionRequest {
+    
+    const filterSensitiveLog: (obj: CreateProxySessionRequest) => any;
+}
+
+export interface Participant {
+    
+    PhoneNumber?: string;
+    
+    ProxyPhoneNumber?: string;
+}
+export declare namespace Participant {
+    
+    const filterSensitiveLog: (obj: Participant) => any;
+}
+export declare enum ProxySessionStatus {
+    Closed = "Closed",
+    InProgress = "InProgress",
+    Open = "Open"
+}
+
+export interface ProxySession {
+    
+    VoiceConnectorId?: string;
+    
+    ProxySessionId?: string;
+    
+    Name?: string;
+    
+    Status?: ProxySessionStatus | string;
+    
+    ExpiryMinutes?: number;
+    
+    Capabilities?: (Capability | string)[];
+    
+    CreatedTimestamp?: Date;
+    
+    UpdatedTimestamp?: Date;
+    
+    EndedTimestamp?: Date;
+    
+    Participants?: Participant[];
+    
+    NumberSelectionBehavior?: NumberSelectionBehavior | string;
+    
+    GeoMatchLevel?: GeoMatchLevel | string;
+    
+    GeoMatchParams?: GeoMatchParams;
+}
+export declare namespace ProxySession {
+    
+    const filterSensitiveLog: (obj: ProxySession) => any;
+}
+export interface CreateProxySessionResponse {
+    
+    ProxySession?: ProxySession;
+}
+export declare namespace CreateProxySessionResponse {
+    
+    const filterSensitiveLog: (obj: CreateProxySessionResponse) => any;
+}
+export interface CreateRoomRequest {
+    
+    AccountId: string | undefined;
+    
+    Name: string | undefined;
+    
+    ClientRequestToken?: string;
+}
+export declare namespace CreateRoomRequest {
+    
+    const filterSensitiveLog: (obj: CreateRoomRequest) => any;
+}
+
+export interface Room {
+    
+    RoomId?: string;
+    
+    Name?: string;
+    
+    AccountId?: string;
+    
+    CreatedBy?: string;
+    
+    CreatedTimestamp?: Date;
+    
+    UpdatedTimestamp?: Date;
+}
+export declare namespace Room {
+    
+    const filterSensitiveLog: (obj: Room) => any;
+}
+export interface CreateRoomResponse {
+    
+    Room?: Room;
+}
+export declare namespace CreateRoomResponse {
+    
+    const filterSensitiveLog: (obj: CreateRoomResponse) => any;
+}
+export interface CreateRoomMembershipRequest {
+    
+    AccountId: string | undefined;
+    
+    RoomId: string | undefined;
+    
+    MemberId: string | undefined;
+    
+    Role?: RoomMembershipRole | string;
+}
+export declare namespace CreateRoomMembershipRequest {
+    
+    const filterSensitiveLog: (obj: CreateRoomMembershipRequest) => any;
+}
+export declare enum MemberType {
+    Bot = "Bot",
+    User = "User",
+    Webhook = "Webhook"
+}
+
+export interface Member {
+    
+    MemberId?: string;
+    
+    MemberType?: MemberType | string;
+    
+    Email?: string;
+    
+    FullName?: string;
+    
+    AccountId?: string;
+}
+export declare namespace Member {
+    
+    const filterSensitiveLog: (obj: Member) => any;
+}
+
+export interface RoomMembership {
+    
+    RoomId?: string;
+    
+    Member?: Member;
+    
+    Role?: RoomMembershipRole | string;
+    
+    InvitedBy?: string;
+    
+    UpdatedTimestamp?: Date;
+}
+export declare namespace RoomMembership {
+    
+    const filterSensitiveLog: (obj: RoomMembership) => any;
+}
+export interface CreateRoomMembershipResponse {
+    
+    RoomMembership?: RoomMembership;
+}
+export declare namespace CreateRoomMembershipResponse {
+    
+    const filterSensitiveLog: (obj: CreateRoomMembershipResponse) => any;
+}
+
+export interface SipMediaApplicationEndpoint {
+    
+    LambdaArn?: string;
+}
+export declare namespace SipMediaApplicationEndpoint {
+    
+    const filterSensitiveLog: (obj: SipMediaApplicationEndpoint) => any;
+}
+export interface CreateSipMediaApplicationRequest {
+    
+    AwsRegion: string | undefined;
+    
+    Name: string | undefined;
+    
+    Endpoints: SipMediaApplicationEndpoint[] | undefined;
+}
+export declare namespace CreateSipMediaApplicationRequest {
+    
+    const filterSensitiveLog: (obj: CreateSipMediaApplicationRequest) => any;
+}
+
+export interface SipMediaApplication {
+    
+    SipMediaApplicationId?: string;
+    
+    AwsRegion?: string;
+    
+    Name?: string;
+    
+    Endpoints?: SipMediaApplicationEndpoint[];
+    
+    CreatedTimestamp?: Date;
+    
+    UpdatedTimestamp?: Date;
+}
+export declare namespace SipMediaApplication {
+    
+    const filterSensitiveLog: (obj: SipMediaApplication) => any;
+}
+export interface CreateSipMediaApplicationResponse {
+    
+    SipMediaApplication?: SipMediaApplication;
+}
+export declare namespace CreateSipMediaApplicationResponse {
+    
+    const filterSensitiveLog: (obj: CreateSipMediaApplicationResponse) => any;
+}
+export interface CreateSipMediaApplicationCallRequest {
+    
+    FromPhoneNumber: string | undefined;
+    
+    ToPhoneNumber: string | undefined;
+    
+    SipMediaApplicationId: string | undefined;
+    
+    SipHeaders?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateSipMediaApplicationCallRequest {
+    
+    const filterSensitiveLog: (obj: CreateSipMediaApplicationCallRequest) => any;
+}
+
+export interface SipMediaApplicationCall {
+    
+    TransactionId?: string;
+}
+export declare namespace SipMediaApplicationCall {
+    
+    const filterSensitiveLog: (obj: SipMediaApplicationCall) => any;
+}
+export interface CreateSipMediaApplicationCallResponse {
+    
+    SipMediaApplicationCall?: SipMediaApplicationCall;
+}
+export declare namespace CreateSipMediaApplicationCallResponse {
+    
+    const filterSensitiveLog: (obj: CreateSipMediaApplicationCallResponse) => any;
+}
+
+export interface SipRuleTargetApplication {
+    
+    SipMediaApplicationId?: string;
+    
+    Priority?: number;
+    
+    AwsRegion?: string;
+}
+export declare namespace SipRuleTargetApplication {
+    
+    const filterSensitiveLog: (obj: SipRuleTargetApplication) => any;
+}
+export declare enum SipRuleTriggerType {
+    RequestUriHostname = "RequestUriHostname",
+    ToPhoneNumber = "ToPhoneNumber"
+}
+export interface CreateSipRuleRequest {
+    
+    Name: string | undefined;
+    
+    TriggerType: SipRuleTriggerType | string | undefined;
+    
+    TriggerValue: string | undefined;
+    
+    Disabled?: boolean;
+    
+    TargetApplications: SipRuleTargetApplication[] | undefined;
+}
+export declare namespace CreateSipRuleRequest {
+    
+    const filterSensitiveLog: (obj: CreateSipRuleRequest) => any;
+}
+
+export interface SipRule {
+    
+    SipRuleId?: string;
+    
+    Name?: string;
+    
+    Disabled?: boolean;
+    
+    TriggerType?: SipRuleTriggerType | string;
+    
+    TriggerValue?: string;
+    
+    TargetApplications?: SipRuleTargetApplication[];
+    
+    CreatedTimestamp?: Date;
+    
+    UpdatedTimestamp?: Date;
+}
+export declare namespace SipRule {
+    
+    const filterSensitiveLog: (obj: SipRule) => any;
+}
+export interface CreateSipRuleResponse {
+    
+    SipRule?: SipRule;
+}
+export declare namespace CreateSipRuleResponse {
+    
+    const filterSensitiveLog: (obj: CreateSipRuleResponse) => any;
+}
+export interface CreateUserRequest {
+    
+    AccountId: string | undefined;
+    
+    Username?: string;
+    
+    Email?: string;
+    
+    UserType?: UserType | string;
+}
+export declare namespace CreateUserRequest {
+    
+    const filterSensitiveLog: (obj: CreateUserRequest) => any;
+}
+export declare enum InviteStatus {
+    Accepted = "Accepted",
+    Failed = "Failed",
+    Pending = "Pending"
+}
+export declare enum RegistrationStatus {
+    Registered = "Registered",
+    Suspended = "Suspended",
+    Unregistered = "Unregistered"
+}
+
+export interface User {
+    
+    UserId: string | undefined;
+    
+    AccountId?: string;
+    
+    PrimaryEmail?: string;
+    
+    PrimaryProvisionedNumber?: string;
+    
+    DisplayName?: string;
+    
+    LicenseType?: License | string;
+    
+    UserType?: UserType | string;
+    
+    UserRegistrationStatus?: RegistrationStatus | string;
+    
+    UserInvitationStatus?: InviteStatus | string;
+    
+    RegisteredOn?: Date;
+    
+    InvitedOn?: Date;
+    
+    AlexaForBusinessMetadata?: AlexaForBusinessMetadata;
+    
+    PersonalPIN?: string;
+}
+export declare namespace User {
+    
+    const filterSensitiveLog: (obj: User) => any;
+}
+export interface CreateUserResponse {
+    
+    User?: User;
+}
+export declare namespace CreateUserResponse {
+    
+    const filterSensitiveLog: (obj: CreateUserResponse) => any;
+}
+export declare enum VoiceConnectorAwsRegion {
+    US_EAST_1 = "us-east-1",
+    US_WEST_2 = "us-west-2"
+}
+export interface CreateVoiceConnectorRequest {
+    
+    Name: string | undefined;
+    
+    AwsRegion?: VoiceConnectorAwsRegion | string;
+    
+    RequireEncryption: boolean | undefined;
+}
+export declare namespace CreateVoiceConnectorRequest {
+    
+    const filterSensitiveLog: (obj: CreateVoiceConnectorRequest) => any;
+}
+
+export interface VoiceConnector {
+    
+    VoiceConnectorId?: string;
+    
+    AwsRegion?: VoiceConnectorAwsRegion | string;
+    
+    Name?: string;
+    
+    OutboundHostName?: string;
+    
+    RequireEncryption?: boolean;
+    
+    CreatedTimestamp?: Date;
+    
+    UpdatedTimestamp?: Date;
+    
+    VoiceConnectorArn?: string;
+}
+export declare namespace VoiceConnector {
+    
+    const filterSensitiveLog: (obj: VoiceConnector) => any;
+}
+export interface CreateVoiceConnectorResponse {
+    
+    VoiceConnector?: VoiceConnector;
+}
+export declare namespace CreateVoiceConnectorResponse {
+    
+    const filterSensitiveLog: (obj: CreateVoiceConnectorResponse) => any;
+}
+
+export interface VoiceConnectorItem {
+    
+    VoiceConnectorId: string | undefined;
+    
+    Priority: number | undefined;
+}
+export declare namespace VoiceConnectorItem {
+    
+    const filterSensitiveLog: (obj: VoiceConnectorItem) => any;
+}
+export interface CreateVoiceConnectorGroupRequest {
+    
+    Name: string | undefined;
+    
+    VoiceConnectorItems?: VoiceConnectorItem[];
+}
+export declare namespace CreateVoiceConnectorGroupRequest {
+    
+    const filterSensitiveLog: (obj: CreateVoiceConnectorGroupRequest) => any;
+}
+
+export interface VoiceConnectorGroup {
+    
+    VoiceConnectorGroupId?: string;
+    
+    Name?: string;
+    
+    VoiceConnectorItems?: VoiceConnectorItem[];
+    
+    CreatedTimestamp?: Date;
+    
+    UpdatedTimestamp?: Date;
+    
+    VoiceConnectorGroupArn?: string;
+}
+export declare namespace VoiceConnectorGroup {
+    
+    const filterSensitiveLog: (obj: VoiceConnectorGroup) => any;
+}
+export interface CreateVoiceConnectorGroupResponse {
+    
+    VoiceConnectorGroup?: VoiceConnectorGroup;
+}
+export declare namespace CreateVoiceConnectorGroupResponse {
+    
+    const filterSensitiveLog: (obj: CreateVoiceConnectorGroupResponse) => any;
+}
+
+export interface Credential {
+    
+    Username?: string;
+    
+    Password?: string;
+}
+export declare namespace Credential {
+    
+    const filterSensitiveLog: (obj: Credential) => any;
+}
+export interface DeleteAccountRequest {
+    
+    AccountId: string | undefined;
+}
+export declare namespace DeleteAccountRequest {
+    
+    const filterSensitiveLog: (obj: DeleteAccountRequest) => any;
+}
+export interface DeleteAccountResponse {
+}
+export declare namespace DeleteAccountResponse {
+    
+    const filterSensitiveLog: (obj: DeleteAccountResponse) => any;
+}
+
+export interface UnprocessableEntityException extends __SmithyException, $MetadataBearer {
+    name: "UnprocessableEntityException";
+    $fault: "client";
+    Code?: ErrorCode | string;
+    Message?: string;
+}
+export interface DeleteAppInstanceRequest {
+    
+    AppInstanceArn: string | undefined;
+}
+export declare namespace DeleteAppInstanceRequest {
+    
+    const filterSensitiveLog: (obj: DeleteAppInstanceRequest) => any;
+}
+export interface DeleteAppInstanceAdminRequest {
+    
+    AppInstanceAdminArn: string | undefined;
+    
+    AppInstanceArn: string | undefined;
+}
+export declare namespace DeleteAppInstanceAdminRequest {
+    
+    const filterSensitiveLog: (obj: DeleteAppInstanceAdminRequest) => any;
+}
+export interface DeleteAppInstanceStreamingConfigurationsRequest {
+    
+    AppInstanceArn: string | undefined;
+}
+export declare namespace DeleteAppInstanceStreamingConfigurationsRequest {
+    
+    const filterSensitiveLog: (obj: DeleteAppInstanceStreamingConfigurationsRequest) => any;
+}
+export interface DeleteAppInstanceUserRequest {
+    
+    AppInstanceUserArn: string | undefined;
+}
+export declare namespace DeleteAppInstanceUserRequest {
+    
+    const filterSensitiveLog: (obj: DeleteAppInstanceUserRequest) => any;
+}
+export interface DeleteAttendeeRequest {
+    
+    MeetingId: string | undefined;
+    
+    AttendeeId: string | undefined;
+}
+export declare namespace DeleteAttendeeRequest {
+    
+    const filterSensitiveLog: (obj: DeleteAttendeeRequest) => any;
+}
+export interface DeleteChannelRequest {
+    
+    ChannelArn: string | undefined;
+    
+    ChimeBearer?: string;
+}
+export declare namespace DeleteChannelRequest {
+    
+    const filterSensitiveLog: (obj: DeleteChannelRequest) => any;
+}
+export interface DeleteChannelBanRequest {
+    
+    ChannelArn: string | undefined;
+    
+    MemberArn: string | undefined;
+    
+    ChimeBearer?: string;
+}
+export declare namespace DeleteChannelBanRequest {
+    
+    const filterSensitiveLog: (obj: DeleteChannelBanRequest) => any;
+}
+export interface DeleteChannelMembershipRequest {
+    
+    ChannelArn: string | undefined;
+    
+    MemberArn: string | undefined;
+    
+    ChimeBearer?: string;
+}
+export declare namespace DeleteChannelMembershipRequest {
+    
+    const filterSensitiveLog: (obj: DeleteChannelMembershipRequest) => any;
+}
+export interface DeleteChannelMessageRequest {
+    
+    ChannelArn: string | undefined;
+    
+    MessageId: string | undefined;
+    
+    ChimeBearer?: string;
+}
+export declare namespace DeleteChannelMessageRequest {
+    
+    const filterSensitiveLog: (obj: DeleteChannelMessageRequest) => any;
+}
+export interface DeleteChannelModeratorRequest {
+    
+    ChannelArn: string | undefined;
+    
+    ChannelModeratorArn: string | undefined;
+    
+    ChimeBearer?: string;
+}
+export declare namespace DeleteChannelModeratorRequest {
+    
+    const filterSensitiveLog: (obj: DeleteChannelModeratorRequest) => any;
+}
+export interface DeleteEventsConfigurationRequest {
+    
+    AccountId: string | undefined;
+    
+    BotId: string | undefined;
+}
+export declare namespace DeleteEventsConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteEventsConfigurationRequest) => any;
+}
+export interface DeleteMediaCapturePipelineRequest {
+    
+    MediaPipelineId: string | undefined;
+}
+export declare namespace DeleteMediaCapturePipelineRequest {
+    
+    const filterSensitiveLog: (obj: DeleteMediaCapturePipelineRequest) => any;
+}
+export interface DeleteMeetingRequest {
+    
+    MeetingId: string | undefined;
+}
+export declare namespace DeleteMeetingRequest {
+    
+    const filterSensitiveLog: (obj: DeleteMeetingRequest) => any;
+}
+export interface DeletePhoneNumberRequest {
+    
+    PhoneNumberId: string | undefined;
+}
+export declare namespace DeletePhoneNumberRequest {
+    
+    const filterSensitiveLog: (obj: DeletePhoneNumberRequest) => any;
+}
+export interface DeleteProxySessionRequest {
+    
+    VoiceConnectorId: string | undefined;
+    
+    ProxySessionId: string | undefined;
+}
+export declare namespace DeleteProxySessionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteProxySessionRequest) => any;
+}
+export interface DeleteRoomRequest {
+    
+    AccountId: string | undefined;
+    
+    RoomId: string | undefined;
+}
+export declare namespace DeleteRoomRequest {
+    
+    const filterSensitiveLog: (obj: DeleteRoomRequest) => any;
+}
+export interface DeleteRoomMembershipRequest {
+    
+    AccountId: string | undefined;
+    
+    RoomId: string | undefined;
+    
+    MemberId: string | undefined;
+}
+export declare namespace DeleteRoomMembershipRequest {
+    
+    const filterSensitiveLog: (obj: DeleteRoomMembershipRequest) => any;
+}
+export interface DeleteSipMediaApplicationRequest {
+    
+    SipMediaApplicationId: string | undefined;
+}
+export declare namespace DeleteSipMediaApplicationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteSipMediaApplicationRequest) => any;
+}
+export interface DeleteSipRuleRequest {
+    
+    SipRuleId: string | undefined;
+}
+export declare namespace DeleteSipRuleRequest {
+    
+    const filterSensitiveLog: (obj: DeleteSipRuleRequest) => any;
+}
+export interface DeleteVoiceConnectorRequest {
+    
+    VoiceConnectorId: string | undefined;
+}
+export declare namespace DeleteVoiceConnectorRequest {
+    
+    const filterSensitiveLog: (obj: DeleteVoiceConnectorRequest) => any;
+}
+export interface DeleteVoiceConnectorEmergencyCallingConfigurationRequest {
+    
+    VoiceConnectorId: string | undefined;
+}
+export declare namespace DeleteVoiceConnectorEmergencyCallingConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteVoiceConnectorEmergencyCallingConfigurationRequest) => any;
+}
+export interface DeleteVoiceConnectorGroupRequest {
+    
+    VoiceConnectorGroupId: string | undefined;
+}
+export declare namespace DeleteVoiceConnectorGroupRequest {
+    
+    const filterSensitiveLog: (obj: DeleteVoiceConnectorGroupRequest) => any;
+}
+export interface DeleteVoiceConnectorOriginationRequest {
+    
+    VoiceConnectorId: string | undefined;
+}
+export declare namespace DeleteVoiceConnectorOriginationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteVoiceConnectorOriginationRequest) => any;
+}
+export interface DeleteVoiceConnectorProxyRequest {
+    
+    VoiceConnectorId: string | undefined;
+}
+export declare namespace DeleteVoiceConnectorProxyRequest {
+    
+    const filterSensitiveLog: (obj: DeleteVoiceConnectorProxyRequest) => any;
+}
+export interface DeleteVoiceConnectorStreamingConfigurationRequest {
+    
+    VoiceConnectorId: string | undefined;
+}
+export declare namespace DeleteVoiceConnectorStreamingConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteVoiceConnectorStreamingConfigurationRequest) => any;
+}
+export interface DeleteVoiceConnectorTerminationRequest {
+    
+    VoiceConnectorId: string | undefined;
+}
+export declare namespace DeleteVoiceConnectorTerminationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteVoiceConnectorTerminationRequest) => any;
+}
+export interface DeleteVoiceConnectorTerminationCredentialsRequest {
+    
+    VoiceConnectorId: string | undefined;
+    
+    Usernames: string[] | undefined;
+}
+export declare namespace DeleteVoiceConnectorTerminationCredentialsRequest {
+    
+    const filterSensitiveLog: (obj: DeleteVoiceConnectorTerminationCredentialsRequest) => any;
+}
+export interface DescribeAppInstanceRequest {
+    
+    AppInstanceArn: string | undefined;
+}
+export declare namespace DescribeAppInstanceRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAppInstanceRequest) => any;
+}
+export interface DescribeAppInstanceResponse {
+    
+    AppInstance?: AppInstance;
+}
+export declare namespace DescribeAppInstanceResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAppInstanceResponse) => any;
+}
+export interface DescribeAppInstanceAdminRequest {
+    
+    AppInstanceAdminArn: string | undefined;
+    
+    AppInstanceArn: string | undefined;
+}
+export declare namespace DescribeAppInstanceAdminRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAppInstanceAdminRequest) => any;
+}
+export interface DescribeAppInstanceAdminResponse {
+    
+    AppInstanceAdmin?: AppInstanceAdmin;
+}
+export declare namespace DescribeAppInstanceAdminResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAppInstanceAdminResponse) => any;
+}
+export interface DescribeAppInstanceUserRequest {
+    
+    AppInstanceUserArn: string | undefined;
+}
+export declare namespace DescribeAppInstanceUserRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAppInstanceUserRequest) => any;
+}
+export interface DescribeAppInstanceUserResponse {
+    
+    AppInstanceUser?: AppInstanceUser;
+}
+export declare namespace DescribeAppInstanceUserResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAppInstanceUserResponse) => any;
+}
+export interface DescribeChannelRequest {
+    
+    ChannelArn: string | undefined;
+    
+    ChimeBearer?: string;
+}
+export declare namespace DescribeChannelRequest {
+    
+    const filterSensitiveLog: (obj: DescribeChannelRequest) => any;
+}
+export interface DescribeChannelResponse {
+    
+    Channel?: Channel;
+}
+export declare namespace DescribeChannelResponse {
+    
+    const filterSensitiveLog: (obj: DescribeChannelResponse) => any;
+}
+export interface DescribeChannelBanRequest {
+    
+    ChannelArn: string | undefined;
+    
+    MemberArn: string | undefined;
+    
+    ChimeBearer?: string;
+}
+export declare namespace DescribeChannelBanRequest {
+    
+    const filterSensitiveLog: (obj: DescribeChannelBanRequest) => any;
+}
+export interface DescribeChannelBanResponse {
+    
+    ChannelBan?: ChannelBan;
+}
+export declare namespace DescribeChannelBanResponse {
+    
+    const filterSensitiveLog: (obj: DescribeChannelBanResponse) => any;
+}
+export interface DescribeChannelMembershipRequest {
+    
+    ChannelArn: string | undefined;
+    
+    MemberArn: string | undefined;
+    
+    ChimeBearer?: string;
+}
+export declare namespace DescribeChannelMembershipRequest {
+    
+    const filterSensitiveLog: (obj: DescribeChannelMembershipRequest) => any;
+}
+export interface DescribeChannelMembershipResponse {
+    
+    ChannelMembership?: ChannelMembership;
+}
+export declare namespace DescribeChannelMembershipResponse {
+    
+    const filterSensitiveLog: (obj: DescribeChannelMembershipResponse) => any;
+}
+export interface DescribeChannelMembershipForAppInstanceUserRequest {
+    
+    ChannelArn: string | undefined;
+    
+    AppInstanceUserArn: string | undefined;
+    
+    ChimeBearer?: string;
+}
+export declare namespace DescribeChannelMembershipForAppInstanceUserRequest {
+    
+    const filterSensitiveLog: (obj: DescribeChannelMembershipForAppInstanceUserRequest) => any;
+}
+export interface DescribeChannelMembershipForAppInstanceUserResponse {
+    
+    ChannelMembership?: ChannelMembershipForAppInstanceUserSummary;
+}
+export declare namespace DescribeChannelMembershipForAppInstanceUserResponse {
+    
+    const filterSensitiveLog: (obj: DescribeChannelMembershipForAppInstanceUserResponse) => any;
+}
+export interface DescribeChannelModeratedByAppInstanceUserRequest {
+    
+    ChannelArn: string | undefined;
+    
+    AppInstanceUserArn: string | undefined;
+    
+    ChimeBearer?: string;
+}
+export declare namespace DescribeChannelModeratedByAppInstanceUserRequest {
+    
+    const filterSensitiveLog: (obj: DescribeChannelModeratedByAppInstanceUserRequest) => any;
+}
+export interface DescribeChannelModeratedByAppInstanceUserResponse {
+    
+    Channel?: ChannelModeratedByAppInstanceUserSummary;
+}
+export declare namespace DescribeChannelModeratedByAppInstanceUserResponse {
+    
+    const filterSensitiveLog: (obj: DescribeChannelModeratedByAppInstanceUserResponse) => any;
+}
+export interface DescribeChannelModeratorRequest {
+    
+    ChannelArn: string | undefined;
+    
+    ChannelModeratorArn: string | undefined;
+    
+    ChimeBearer?: string;
+}
+export declare namespace DescribeChannelModeratorRequest {
+    
+    const filterSensitiveLog: (obj: DescribeChannelModeratorRequest) => any;
+}
+export interface DescribeChannelModeratorResponse {
+    
+    ChannelModerator?: ChannelModerator;
+}
+export declare namespace DescribeChannelModeratorResponse {
+    
+    const filterSensitiveLog: (obj: DescribeChannelModeratorResponse) => any;
+}
+export interface DisassociatePhoneNumberFromUserRequest {
+    
+    AccountId: string | undefined;
+    
+    UserId: string | undefined;
+}
+export declare namespace DisassociatePhoneNumberFromUserRequest {
+    
+    const filterSensitiveLog: (obj: DisassociatePhoneNumberFromUserRequest) => any;
+}
+export interface DisassociatePhoneNumberFromUserResponse {
+}
+export declare namespace DisassociatePhoneNumberFromUserResponse {
+    
+    const filterSensitiveLog: (obj: DisassociatePhoneNumberFromUserResponse) => any;
+}
+export interface DisassociatePhoneNumbersFromVoiceConnectorRequest {
+    
+    VoiceConnectorId: string | undefined;
+    
+    E164PhoneNumbers: string[] | undefined;
+}
+export declare namespace DisassociatePhoneNumbersFromVoiceConnectorRequest {
+    
+    const filterSensitiveLog: (obj: DisassociatePhoneNumbersFromVoiceConnectorRequest) => any;
+}
+export interface DisassociatePhoneNumbersFromVoiceConnectorResponse {
+    
+    PhoneNumberErrors?: PhoneNumberError[];
+}
+export declare namespace DisassociatePhoneNumbersFromVoiceConnectorResponse {
+    
+    const filterSensitiveLog: (obj: DisassociatePhoneNumbersFromVoiceConnectorResponse) => any;
+}
+export interface DisassociatePhoneNumbersFromVoiceConnectorGroupRequest {
+    
+    VoiceConnectorGroupId: string | undefined;
+    
+    E164PhoneNumbers: string[] | undefined;
+}
+export declare namespace DisassociatePhoneNumbersFromVoiceConnectorGroupRequest {
+    
+    const filterSensitiveLog: (obj: DisassociatePhoneNumbersFromVoiceConnectorGroupRequest) => any;
+}
+export interface DisassociatePhoneNumbersFromVoiceConnectorGroupResponse {
+    
+    PhoneNumberErrors?: PhoneNumberError[];
+}
+export declare namespace DisassociatePhoneNumbersFromVoiceConnectorGroupResponse {
+    
+    const filterSensitiveLog: (obj: DisassociatePhoneNumbersFromVoiceConnectorGroupResponse) => any;
+}
+export interface DisassociateSigninDelegateGroupsFromAccountRequest {
+    
+    AccountId: string | undefined;
+    
+    GroupNames: string[] | undefined;
+}
+export declare namespace DisassociateSigninDelegateGroupsFromAccountRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateSigninDelegateGroupsFromAccountRequest) => any;
+}
+export interface DisassociateSigninDelegateGroupsFromAccountResponse {
+}
+export declare namespace DisassociateSigninDelegateGroupsFromAccountResponse {
+    
+    const filterSensitiveLog: (obj: DisassociateSigninDelegateGroupsFromAccountResponse) => any;
+}
+
+export interface DNISEmergencyCallingConfiguration {
+    
+    EmergencyPhoneNumber: string | undefined;
+    
+    TestPhoneNumber?: string;
+    
+    CallingCountry: string | undefined;
+}
+export declare namespace DNISEmergencyCallingConfiguration {
+    
+    const filterSensitiveLog: (obj: DNISEmergencyCallingConfiguration) => any;
+}
+export declare enum EmailStatus {
+    Failed = "Failed",
+    NotSent = "NotSent",
+    Sent = "Sent"
+}
+
+export interface EmergencyCallingConfiguration {
+    
+    DNIS?: DNISEmergencyCallingConfiguration[];
+}
+export declare namespace EmergencyCallingConfiguration {
+    
+    const filterSensitiveLog: (obj: EmergencyCallingConfiguration) => any;
+}
+export declare enum TranscribeMedicalContentIdentificationType {
+    PHI = "PHI"
+}
+export declare enum TranscribeMedicalLanguageCode {
+    EN_US = "en-US"
+}
+export declare enum TranscribeMedicalRegion {
+    AP_SOUTHEAST_2 = "ap-southeast-2",
+    AUTO = "auto",
+    CA_CENTRAL_1 = "ca-central-1",
+    EU_WEST_1 = "eu-west-1",
+    US_EAST_1 = "us-east-1",
+    US_EAST_2 = "us-east-2",
+    US_WEST_2 = "us-west-2"
+}
+export declare enum TranscribeMedicalSpecialty {
+    Cardiology = "CARDIOLOGY",
+    Neurology = "NEUROLOGY",
+    Oncology = "ONCOLOGY",
+    PrimaryCare = "PRIMARYCARE",
+    Radiology = "RADIOLOGY",
+    Urology = "UROLOGY"
+}
+export declare enum TranscribeMedicalType {
+    Conversation = "CONVERSATION",
+    Dictation = "DICTATION"
+}
+
+export interface EngineTranscribeMedicalSettings {
+    
+    LanguageCode: TranscribeMedicalLanguageCode | string | undefined;
+    
+    Specialty: TranscribeMedicalSpecialty | string | undefined;
+    
+    Type: TranscribeMedicalType | string | undefined;
+    
+    VocabularyName?: string;
+    
+    Region?: TranscribeMedicalRegion | string;
+    
+    ContentIdentificationType?: TranscribeMedicalContentIdentificationType | string;
+}
+export declare namespace EngineTranscribeMedicalSettings {
+    
+    const filterSensitiveLog: (obj: EngineTranscribeMedicalSettings) => any;
+}
+export declare enum TranscribeContentIdentificationType {
+    PII = "PII"
+}
+export declare enum TranscribeContentRedactionType {
+    PII = "PII"
+}
+export declare enum TranscribeLanguageCode {
+    DE_DE = "de-DE",
+    EN_AU = "en-AU",
+    EN_GB = "en-GB",
+    EN_US = "en-US",
+    ES_US = "es-US",
+    FR_CA = "fr-CA",
+    FR_FR = "fr-FR",
+    IT_IT = "it-IT",
+    JA_JP = "ja-JP",
+    KO_KR = "ko-KR",
+    PT_BR = "pt-BR",
+    ZH_CN = "zh-CN"
+}
+export declare enum TranscribePartialResultsStability {
+    HIGH = "high",
+    LOW = "low",
+    MEDIUM = "medium"
+}
+export declare enum TranscribeRegion {
+    AP_NORTHEAST_1 = "ap-northeast-1",
+    AP_NORTHEAST_2 = "ap-northeast-2",
+    AP_SOUTHEAST_2 = "ap-southeast-2",
+    AUTO = "auto",
+    CA_CENTRAL_1 = "ca-central-1",
+    EU_CENTRAL_1 = "eu-central-1",
+    EU_WEST_1 = "eu-west-1",
+    EU_WEST_2 = "eu-west-2",
+    SA_EAST_1 = "sa-east-1",
+    US_EAST_1 = "us-east-1",
+    US_EAST_2 = "us-east-2",
+    US_WEST_2 = "us-west-2"
+}
+export declare enum TranscribeVocabularyFilterMethod {
+    Mask = "mask",
+    Remove = "remove",
+    Tag = "tag"
+}
+
+export interface EngineTranscribeSettings {
+    
+    LanguageCode: TranscribeLanguageCode | string | undefined;
+    
+    VocabularyFilterMethod?: TranscribeVocabularyFilterMethod | string;
+    
+    VocabularyFilterName?: string;
+    
+    VocabularyName?: string;
+    
+    Region?: TranscribeRegion | string;
+    
+    EnablePartialResultsStabilization?: boolean;
+    
+    PartialResultsStability?: TranscribePartialResultsStability | string;
+    
+    ContentIdentificationType?: TranscribeContentIdentificationType | string;
+    
+    ContentRedactionType?: TranscribeContentRedactionType | string;
+    
+    PiiEntityTypes?: string;
+    
+    LanguageModelName?: string;
+}
+export declare namespace EngineTranscribeSettings {
+    
+    const filterSensitiveLog: (obj: EngineTranscribeSettings) => any;
+}
+
+export interface EventsConfiguration {
+    
+    BotId?: string;
+    
+    OutboundEventsHTTPSEndpoint?: string;
+    
+    LambdaFunctionArn?: string;
+}
+export declare namespace EventsConfiguration {
+    
+    const filterSensitiveLog: (obj: EventsConfiguration) => any;
+}
+export interface GetAccountRequest {
+    
+    AccountId: string | undefined;
+}
+export declare namespace GetAccountRequest {
+    
+    const filterSensitiveLog: (obj: GetAccountRequest) => any;
+}
+export interface GetAccountResponse {
+    
+    Account?: Account;
+}
+export declare namespace GetAccountResponse {
+    
+    const filterSensitiveLog: (obj: GetAccountResponse) => any;
+}
+export interface GetAccountSettingsRequest {
+    
+    AccountId: string | undefined;
+}
+export declare namespace GetAccountSettingsRequest {
+    
+    const filterSensitiveLog: (obj: GetAccountSettingsRequest) => any;
+}
+export interface GetAccountSettingsResponse {
+    
+    AccountSettings?: AccountSettings;
+}
+export declare namespace GetAccountSettingsResponse {
+    
+    const filterSensitiveLog: (obj: GetAccountSettingsResponse) => any;
+}
+export interface GetAppInstanceRetentionSettingsRequest {
+    
+    AppInstanceArn: string | undefined;
+}
+export declare namespace GetAppInstanceRetentionSettingsRequest {
+    
+    const filterSensitiveLog: (obj: GetAppInstanceRetentionSettingsRequest) => any;
+}
+export interface GetAppInstanceRetentionSettingsResponse {
+    
+    AppInstanceRetentionSettings?: AppInstanceRetentionSettings;
+    
+    InitiateDeletionTimestamp?: Date;
+}
+export declare namespace GetAppInstanceRetentionSettingsResponse {
+    
+    const filterSensitiveLog: (obj: GetAppInstanceRetentionSettingsResponse) => any;
+}
+export interface GetAppInstanceStreamingConfigurationsRequest {
+    
+    AppInstanceArn: string | undefined;
+}
+export declare namespace GetAppInstanceStreamingConfigurationsRequest {
+    
+    const filterSensitiveLog: (obj: GetAppInstanceStreamingConfigurationsRequest) => any;
+}
+export interface GetAppInstanceStreamingConfigurationsResponse {
+    
+    AppInstanceStreamingConfigurations?: AppInstanceStreamingConfiguration[];
+}
+export declare namespace GetAppInstanceStreamingConfigurationsResponse {
+    
+    const filterSensitiveLog: (obj: GetAppInstanceStreamingConfigurationsResponse) => any;
+}
+export interface GetAttendeeRequest {
+    
+    MeetingId: string | undefined;
+    
+    AttendeeId: string | undefined;
+}
+export declare namespace GetAttendeeRequest {
+    
+    const filterSensitiveLog: (obj: GetAttendeeRequest) => any;
+}
+export interface GetAttendeeResponse {
+    
+    Attendee?: Attendee;
+}
+export declare namespace GetAttendeeResponse {
+    
+    const filterSensitiveLog: (obj: GetAttendeeResponse) => any;
+}
+export interface GetBotRequest {
+    
+    AccountId: string | undefined;
+    
+    BotId: string | undefined;
+}
+export declare namespace GetBotRequest {
+    
+    const filterSensitiveLog: (obj: GetBotRequest) => any;
+}
+export interface GetBotResponse {
+    
+    Bot?: Bot;
+}
+export declare namespace GetBotResponse {
+    
+    const filterSensitiveLog: (obj: GetBotResponse) => any;
+}
+export interface GetChannelMessageRequest {
+    
+    ChannelArn: string | undefined;
+    
+    MessageId: string | undefined;
+    
+    ChimeBearer?: string;
+}
+export declare namespace GetChannelMessageRequest {
+    
+    const filterSensitiveLog: (obj: GetChannelMessageRequest) => any;
+}
+export interface GetChannelMessageResponse {
+    
+    ChannelMessage?: ChannelMessage;
+}
+export declare namespace GetChannelMessageResponse {
+    
+    const filterSensitiveLog: (obj: GetChannelMessageResponse) => any;
+}
+export interface GetEventsConfigurationRequest {
+    
+    AccountId: string | undefined;
+    
+    BotId: string | undefined;
+}
+export declare namespace GetEventsConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: GetEventsConfigurationRequest) => any;
+}
+export interface GetEventsConfigurationResponse {
+    
+    EventsConfiguration?: EventsConfiguration;
+}
+export declare namespace GetEventsConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: GetEventsConfigurationResponse) => any;
+}
+
+export interface VoiceConnectorSettings {
+    
+    CdrBucket?: string;
+}
+export declare namespace VoiceConnectorSettings {
+    
+    const filterSensitiveLog: (obj: VoiceConnectorSettings) => any;
+}
+export interface GetGlobalSettingsResponse {
+    
+    BusinessCalling?: BusinessCallingSettings;
+    
+    VoiceConnector?: VoiceConnectorSettings;
+}
+export declare namespace GetGlobalSettingsResponse {
+    
+    const filterSensitiveLog: (obj: GetGlobalSettingsResponse) => any;
+}
+export interface GetMediaCapturePipelineRequest {
+    
+    MediaPipelineId: string | undefined;
+}
+export declare namespace GetMediaCapturePipelineRequest {
+    
+    const filterSensitiveLog: (obj: GetMediaCapturePipelineRequest) => any;
+}
+export interface GetMediaCapturePipelineResponse {
+    
+    MediaCapturePipeline?: MediaCapturePipeline;
+}
+export declare namespace GetMediaCapturePipelineResponse {
+    
+    const filterSensitiveLog: (obj: GetMediaCapturePipelineResponse) => any;
+}
+export interface GetMeetingRequest {
+    
+    MeetingId: string | undefined;
+}
+export declare namespace GetMeetingRequest {
+    
+    const filterSensitiveLog: (obj: GetMeetingRequest) => any;
+}
+export interface GetMeetingResponse {
+    
+    Meeting?: Meeting;
+}
+export declare namespace GetMeetingResponse {
+    
+    const filterSensitiveLog: (obj: GetMeetingResponse) => any;
+}
+export interface GetMessagingSessionEndpointRequest {
+}
+export declare namespace GetMessagingSessionEndpointRequest {
+    
+    const filterSensitiveLog: (obj: GetMessagingSessionEndpointRequest) => any;
+}
+
+export interface MessagingSessionEndpoint {
+    
+    Url?: string;
+}
+export declare namespace MessagingSessionEndpoint {
+    
+    const filterSensitiveLog: (obj: MessagingSessionEndpoint) => any;
+}
+export interface GetMessagingSessionEndpointResponse {
+    
+    Endpoint?: MessagingSessionEndpoint;
+}
+export declare namespace GetMessagingSessionEndpointResponse {
+    
+    const filterSensitiveLog: (obj: GetMessagingSessionEndpointResponse) => any;
+}
+export interface GetPhoneNumberRequest {
+    
+    PhoneNumberId: string | undefined;
+}
+export declare namespace GetPhoneNumberRequest {
+    
+    const filterSensitiveLog: (obj: GetPhoneNumberRequest) => any;
+}
+export declare enum PhoneNumberAssociationName {
+    AccountId = "AccountId",
+    SipRuleId = "SipRuleId",
+    UserId = "UserId",
+    VoiceConnectorGroupId = "VoiceConnectorGroupId",
+    VoiceConnectorId = "VoiceConnectorId"
+}
+
+export interface PhoneNumberAssociation {
+    
+    Value?: string;
+    
+    Name?: PhoneNumberAssociationName | string;
+    
+    AssociatedTimestamp?: Date;
+}
+export declare namespace PhoneNumberAssociation {
+    
+    const filterSensitiveLog: (obj: PhoneNumberAssociation) => any;
+}
+
+export interface PhoneNumberCapabilities {
+    
+    InboundCall?: boolean;
+    
+    OutboundCall?: boolean;
+    
+    InboundSMS?: boolean;
+    
+    OutboundSMS?: boolean;
+    
+    InboundMMS?: boolean;
+    
+    OutboundMMS?: boolean;
+}
+export declare namespace PhoneNumberCapabilities {
+    
+    const filterSensitiveLog: (obj: PhoneNumberCapabilities) => any;
+}
+export declare enum PhoneNumberStatus {
+    AcquireFailed = "AcquireFailed",
+    AcquireInProgress = "AcquireInProgress",
+    Assigned = "Assigned",
+    DeleteFailed = "DeleteFailed",
+    DeleteInProgress = "DeleteInProgress",
+    ReleaseFailed = "ReleaseFailed",
+    ReleaseInProgress = "ReleaseInProgress",
+    Unassigned = "Unassigned"
+}
+export declare enum PhoneNumberType {
+    Local = "Local",
+    TollFree = "TollFree"
+}
+
+export interface PhoneNumber {
+    
+    PhoneNumberId?: string;
+    
+    E164PhoneNumber?: string;
+    
+    Country?: string;
+    
+    Type?: PhoneNumberType | string;
+    
+    ProductType?: PhoneNumberProductType | string;
+    
+    Status?: PhoneNumberStatus | string;
+    
+    Capabilities?: PhoneNumberCapabilities;
+    
+    Associations?: PhoneNumberAssociation[];
+    
+    CallingName?: string;
+    
+    CallingNameStatus?: CallingNameStatus | string;
+    
+    CreatedTimestamp?: Date;
+    
+    UpdatedTimestamp?: Date;
+    
+    DeletionTimestamp?: Date;
+}
+export declare namespace PhoneNumber {
+    
+    const filterSensitiveLog: (obj: PhoneNumber) => any;
+}
+export interface GetPhoneNumberResponse {
+    
+    PhoneNumber?: PhoneNumber;
+}
+export declare namespace GetPhoneNumberResponse {
+    
+    const filterSensitiveLog: (obj: GetPhoneNumberResponse) => any;
+}
+export interface GetPhoneNumberOrderRequest {
+    
+    PhoneNumberOrderId: string | undefined;
+}
+export declare namespace GetPhoneNumberOrderRequest {
+    
+    const filterSensitiveLog: (obj: GetPhoneNumberOrderRequest) => any;
+}
+export interface GetPhoneNumberOrderResponse {
+    
+    PhoneNumberOrder?: PhoneNumberOrder;
+}
+export declare namespace GetPhoneNumberOrderResponse {
+    
+    const filterSensitiveLog: (obj: GetPhoneNumberOrderResponse) => any;
+}
+export interface GetPhoneNumberSettingsResponse {
+    
+    CallingName?: string;
+    
+    CallingNameUpdatedTimestamp?: Date;
+}
+export declare namespace GetPhoneNumberSettingsResponse {
+    
+    const filterSensitiveLog: (obj: GetPhoneNumberSettingsResponse) => any;
+}
+export interface GetProxySessionRequest {
+    
+    VoiceConnectorId: string | undefined;
+    
+    ProxySessionId: string | undefined;
+}
+export declare namespace GetProxySessionRequest {
+    
+    const filterSensitiveLog: (obj: GetProxySessionRequest) => any;
+}
+export interface GetProxySessionResponse {
+    
+    ProxySession?: ProxySession;
+}
+export declare namespace GetProxySessionResponse {
+    
+    const filterSensitiveLog: (obj: GetProxySessionResponse) => any;
+}
+export interface GetRetentionSettingsRequest {
+    
+    AccountId: string | undefined;
+}
+export declare namespace GetRetentionSettingsRequest {
+    
+    const filterSensitiveLog: (obj: GetRetentionSettingsRequest) => any;
+}
+
+export interface RoomRetentionSettings {
+    
+    RetentionDays?: number;
+}
+export declare namespace RoomRetentionSettings {
+    
+    const filterSensitiveLog: (obj: RoomRetentionSettings) => any;
+}
+
+export interface RetentionSettings {
+    
+    RoomRetentionSettings?: RoomRetentionSettings;
+    
+    ConversationRetentionSettings?: ConversationRetentionSettings;
+}
+export declare namespace RetentionSettings {
+    
+    const filterSensitiveLog: (obj: RetentionSettings) => any;
+}