communication-react.api.md

## API Report File for "@azure/communication-react"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

/// <reference types="react" />

import { AddPhoneNumberOptions } from '@azure/communication-calling';
import { AudioDeviceInfo } from '@azure/communication-calling';
import { Call } from '@azure/communication-calling';
import { CallAgent } from '@azure/communication-calling';
import { CallClient } from '@azure/communication-calling';
import { CallClientOptions } from '@azure/communication-calling';
import { CallDirection } from '@azure/communication-calling';
import { CallEndReason } from '@azure/communication-calling';
import { CallerInfo } from '@azure/communication-calling';
import { CallState as CallState_2 } from '@azure/communication-calling';
import { ChatClient } from '@azure/communication-chat';
import { ChatClientOptions } from '@azure/communication-chat';
import { ChatMessage as ChatMessage_2 } from '@azure/communication-chat';
import { ChatMessageReadReceipt } from '@azure/communication-chat';
import { ChatParticipant } from '@azure/communication-chat';
import { ChatThreadClient } from '@azure/communication-chat';
import { CommunicationIdentifier } from '@azure/communication-common';
import { CommunicationIdentifierKind } from '@azure/communication-common';
import { CommunicationTokenCredential } from '@azure/communication-common';
import { CommunicationUserIdentifier } from '@azure/communication-common';
import { CommunicationUserKind } from '@azure/communication-common';
import { ComponentSlotStyle } from '@fluentui/react-northstar';
import { CreateViewOptions } from '@azure/communication-calling';
import { DeviceAccess } from '@azure/communication-calling';
import { DeviceManager } from '@azure/communication-calling';
import { DominantSpeakersInfo } from '@azure/communication-calling';
import { DtmfTone as DtmfTone_2 } from '@azure/communication-calling';
import { EnvironmentInfo } from '@azure/communication-calling';
import { GroupCallLocator } from '@azure/communication-calling';
import { IButtonProps } from '@fluentui/react';
import { IButtonStyles } from '@fluentui/react';
import { IContextualMenuItem } from '@fluentui/react';
import { IContextualMenuItemStyles } from '@fluentui/react';
import { IContextualMenuStyles } from '@fluentui/react';
import { IDropdownOption } from '@fluentui/react';
import { IDropdownStyles } from '@fluentui/react';
import { IIconProps } from '@fluentui/react';
import { ILinkStyles } from '@fluentui/react';
import { IMessageBarProps } from '@fluentui/react';
import { IncomingCall } from '@azure/communication-calling';
import { IPersonaStyleProps } from '@fluentui/react';
import { IPersonaStyles } from '@fluentui/react';
import { IRenderFunction } from '@fluentui/react';
import { IStyle } from '@fluentui/react';
import { IStyleFunctionOrObject } from '@fluentui/react';
import { ITextFieldStyles } from '@fluentui/react';
import { LatestMediaDiagnostics } from '@azure/communication-calling';
import { LatestNetworkDiagnostics } from '@azure/communication-calling';
import type { MediaDiagnosticChangedEventArgs } from '@azure/communication-calling';
import { MediaStreamType } from '@azure/communication-calling';
import { MicrosoftTeamsUserKind } from '@azure/communication-common';
import type { NetworkDiagnosticChangedEventArgs } from '@azure/communication-calling';
import { PartialTheme } from '@fluentui/react';
import { ParticipantRole } from '@azure/communication-calling';
import { PermissionConstraints } from '@azure/communication-calling';
import { PersonaInitialsColor } from '@fluentui/react';
import { PersonaPresence } from '@fluentui/react';
import { PersonaSize } from '@fluentui/react';
import { PhoneNumberIdentifier } from '@azure/communication-common';
import { PhoneNumberKind } from '@azure/communication-common';
import { PropertyChangedEvent } from '@azure/communication-calling';
import { default as React_2 } from 'react';
import type { RemoteParticipant } from '@azure/communication-calling';
import { RemoteParticipantState as RemoteParticipantState_2 } from '@azure/communication-calling';
import { RoomCallLocator } from '@azure/communication-calling';
import { ScalingMode } from '@azure/communication-calling';
import { SendMessageOptions } from '@azure/communication-chat';
import { StartCallOptions } from '@azure/communication-calling';
import { TeamsCall } from '@azure/communication-calling';
import { TeamsCallAgent } from '@azure/communication-calling';
import { TeamsMeetingLinkLocator } from '@azure/communication-calling';
import { Theme } from '@fluentui/react';
import { TypingIndicatorReceivedEvent } from '@azure/communication-chat';
import { UnknownIdentifier } from '@azure/communication-common';
import { UnknownIdentifierKind } from '@azure/communication-common';
import { VideoDeviceInfo } from '@azure/communication-calling';
import { VideoStreamRenderer } from '@azure/communication-calling';
import { VideoStreamRendererView } from '@azure/communication-calling';

// @public
export interface ActiveErrorMessage {
    timestamp?: Date;
    type: ErrorType;
}

// @beta
export interface ActiveFileUpload {
    error?: SendBoxErrorBarError;
    filename: string;
    id: string;
    progress: number;
    uploadComplete?: boolean;
}

// @public
export interface AdapterError extends Error {
    innerError: Error;
    target: string;
    timestamp: Date;
}

// @public
export type AdapterErrors = {
    [target: string]: AdapterError;
};

// @public
export interface AdapterState<TState> {
    getState(): TState;
    offStateChange(handler: (state: TState) => void): void;
    onStateChange(handler: (state: TState) => void): void;
}

// @public
export type AreEqual<A extends (props: any) => JSX.Element | undefined, B extends (props: any) => JSX.Element | undefined> = true extends AreTypeEqual<A, B> & AreParamEqual<A, B> ? true : false;

// @public
export type AreParamEqual<A extends (props: any) => JSX.Element | undefined, B extends (props: any) => JSX.Element | undefined> = AreTypeEqual<Required<Parameters<A>[0]>, Required<Parameters<B>[0]>>;

// @public
export type AreTypeEqual<A, B> = A extends B ? (B extends A ? true : false) : false;

// @public
export type AvatarPersonaData = {
    text?: string;
    imageUrl?: string;
    imageInitials?: string;
    initialsColor?: PersonaInitialsColor | string;
    initialsTextColor?: string;
    showUnknownPersonaCoin?: boolean;
};

// @public
export type AvatarPersonaDataCallback = (userId: string) => Promise<AvatarPersonaData>;

// @public
export type AzureCommunicationCallAdapterArgs = {
    userId: CommunicationUserIdentifier;
    displayName: string;
    credential: CommunicationTokenCredential;
    locator: CallAdapterLocator;
    alternateCallerId?: string;
    options?: AzureCommunicationCallAdapterOptions;
};

// @beta
export type AzureCommunicationCallAdapterOptions = {
    roleHint?: Role;
    features?: CallAdapterOptionalFeatures;
};

// @public
export type AzureCommunicationCallWithChatAdapterArgs = {
    endpoint: string;
    userId: CommunicationUserIdentifier;
    displayName: string;
    credential: CommunicationTokenCredential;
    locator: CallAndChatLocator | TeamsMeetingLinkLocator;
    alternateCallerId?: string;
    callAdapterOptions?: AzureCommunicationCallAdapterOptions;
};

// @public
export type AzureCommunicationCallWithChatAdapterFromClientArgs = {
    callLocator: CallAdapterLocator | TeamsMeetingLinkLocator;
    callAgent: CallAgent;
    callClient: StatefulCallClient;
    chatClient: StatefulChatClient;
    chatThreadClient: ChatThreadClient;
};

// @public
export type AzureCommunicationChatAdapterArgs = {
    endpoint: string;
    userId: CommunicationUserIdentifier;
    displayName: string;
    credential: CommunicationTokenCredential;
    threadId: string;
};

// @public
export interface BaseCompositeProps<TIcons extends Record<string, JSX.Element>> {
    fluentTheme?: PartialTheme | Theme;
    icons?: TIcons;
    locale?: CompositeLocale;
    onFetchAvatarPersonaData?: AvatarPersonaDataCallback;
    onFetchParticipantMenuItems?: ParticipantMenuItemsCallback;
    rtl?: boolean;
}

// @public
export interface BaseCustomStyles {
    root?: IStyle;
}

// @beta
export interface BrowserPermissionDeniedIOSProps extends BrowserPermissionDeniedProps {
    imageSource?: string;
    strings?: BrowserPermissionDeniedIOSStrings;
}

// @beta
export interface BrowserPermissionDeniedIOSStrings extends BrowserPermissionDeniedStrings {
    imageAltText: string;
    primaryText: string;
    secondaryText: string;
    step1DigitText: string;
    step1Text: string;
    step2DigitText: string;
    step2Text: string;
    step3DigitText: string;
    step3Text: string;
    step4DigitText: string;
    step4Text: string;
}

// @beta
export interface BrowserPermissionDeniedProps {
    onTroubleshootingClick?: () => void;
    onTryAgainClick?: () => void;
    strings?: BrowserPermissionDeniedStrings;
    styles?: BrowserPermissionDeniedStyles;
}

// @beta
export interface BrowserPermissionDeniedStrings {
    linkText: string;
    primaryButtonText: string;
    primaryText: string;
    secondaryText: string;
}

// @beta
export interface BrowserPermissionDeniedStyles extends BaseCustomStyles {
    primaryButton?: IButtonStyles;
    troubleshootingLink?: ILinkStyles;
}

// @public
export interface CallAdapter extends AdapterState<CallAdapterState>, Disposable, CallAdapterCallManagement, CallAdapterDeviceManagement, CallAdapterSubscribers {
}

// @public
export type CallAdapterCallEndedEvent = {
    callId: string;
};

// @public
export interface CallAdapterCallManagement {
    // @beta
    addParticipant(participant: PhoneNumberIdentifier, options?: AddPhoneNumberOptions): Promise<void>;
    // (undocumented)
    addParticipant(participant: CommunicationUserIdentifier): Promise<void>;
    createStreamView(remoteUserId?: string, options?: VideoStreamOptions): Promise<void | CreateVideoStreamViewResult>;
    disposeStreamView(remoteUserId?: string, options?: VideoStreamOptions): Promise<void>;
    // @beta
    holdCall(): Promise<void>;
    joinCall(microphoneOn?: boolean): Call | undefined;
    leaveCall(forEveryone?: boolean): Promise<void>;
    mute(): Promise<void>;
    removeParticipant(userId: string): Promise<void>;
    // @beta
    removeParticipant(participant: CommunicationIdentifier): Promise<void>;
    // @beta
    resumeCall(): Promise<void>;
    // @beta
    sendDtmfTone(dtmfTone: DtmfTone_2): Promise<void>;
    startCall(participants: string[], options?: StartCallOptions): Call | undefined;
    // @beta
    startCall(participants: CommunicationIdentifier[], options?: StartCallOptions): Call | undefined;
    startCamera(options?: VideoStreamOptions): Promise<void>;
    startScreenShare(): Promise<void>;
    stopCamera(): Promise<void>;
    stopScreenShare(): Promise<void>;
    unmute(): Promise<void>;
}

// @public
export type CallAdapterClientState = {
    userId: CommunicationIdentifierKind;
    displayName?: string;
    call?: CallState;
    devices: DeviceManagerState;
    endedCall?: CallState;
    isTeamsCall: boolean;
    latestErrors: AdapterErrors;
    alternateCallerId?: string;
    environmentInfo?: EnvironmentInfo;
    features?: CallAdapterOptionalFeatures;
    roleHint?: Role;
};

// @public
export interface CallAdapterDeviceManagement {
    askDevicePermission(constrain: PermissionConstraints): Promise<void>;
    queryCameras(): Promise<VideoDeviceInfo[]>;
    queryMicrophones(): Promise<AudioDeviceInfo[]>;
    querySpeakers(): Promise<AudioDeviceInfo[]>;
    setCamera(sourceInfo: VideoDeviceInfo, options?: VideoStreamOptions): Promise<void>;
    setMicrophone(sourceInfo: AudioDeviceInfo): Promise<void>;
    setSpeaker(sourceInfo: AudioDeviceInfo): Promise<void>;
}

// @public
export type CallAdapterLocator = TeamsMeetingLinkLocator | GroupCallLocator | /* @conditional-compile-remove(rooms) */ RoomCallLocator | /* @conditional-compile-remove(teams-adhoc-call) */ /* @conditional-compile-remove(PSTN-calls) */ CallParticipantsLocator;

// @beta
export type CallAdapterOptionalFeatures = {
    unsupportedEnvironment?: boolean;
};

// @public
export type CallAdapterState = CallAdapterUiState & CallAdapterClientState;

// @public
export interface CallAdapterSubscribers {
    off(event: 'participantsJoined', listener: ParticipantsJoinedListener): void;
    off(event: 'participantsLeft', listener: ParticipantsLeftListener): void;
    off(event: 'isMutedChanged', listener: IsMutedChangedListener): void;
    off(event: 'callIdChanged', listener: CallIdChangedListener): void;
    off(event: 'isLocalScreenSharingActiveChanged', listener: IsLocalScreenSharingActiveChangedListener): void;
    off(event: 'displayNameChanged', listener: DisplayNameChangedListener): void;
    off(event: 'isSpeakingChanged', listener: IsSpeakingChangedListener): void;
    off(event: 'callEnded', listener: CallEndedListener): void;
    off(event: 'diagnosticChanged', listener: DiagnosticChangedEventListner): void;
    off(event: 'selectedMicrophoneChanged', listener: PropertyChangedEvent): void;
    off(event: 'selectedSpeakerChanged', listener: PropertyChangedEvent): void;
    off(event: 'error', listener: (e: AdapterError) => void): void;
    on(event: 'participantsJoined', listener: ParticipantsJoinedListener): void;
    on(event: 'participantsLeft', listener: ParticipantsLeftListener): void;
    on(event: 'isMutedChanged', listener: IsMutedChangedListener): void;
    on(event: 'callIdChanged', listener: CallIdChangedListener): void;
    on(event: 'isLocalScreenSharingActiveChanged', listener: IsLocalScreenSharingActiveChangedListener): void;
    on(event: 'displayNameChanged', listener: DisplayNameChangedListener): void;
    on(event: 'isSpeakingChanged', listener: IsSpeakingChangedListener): void;
    on(event: 'callEnded', listener: CallEndedListener): void;
    on(event: 'diagnosticChanged', listener: DiagnosticChangedEventListner): void;
    on(event: 'selectedMicrophoneChanged', listener: PropertyChangedEvent): void;
    on(event: 'selectedSpeakerChanged', listener: PropertyChangedEvent): void;
    on(event: 'error', listener: (e: AdapterError) => void): void;
}

// @public
export type CallAdapterUiState = {
    isLocalPreviewMicrophoneEnabled: boolean;
    page: CallCompositePage;
};

// @public
export const CallAgentProvider: (props: CallAgentProviderProps) => JSX.Element;

// @public
export interface CallAgentProviderProps {
    // (undocumented)
    callAgent?: CallAgent | /* @conditional-compile-remove(teams-identity-support) */ TeamsCallAgent;
    // (undocumented)
    children: React_2.ReactNode;
}

// @public
export interface CallAgentState {
    displayName?: string;
}

// @public
export interface CallAndChatLocator {
    callLocator: GroupCallLocator | /* @conditional-compile-remove(teams-adhoc-call) */ CallParticipantsLocator;
    chatThreadId: string;
}

// @public
export const CallClientProvider: (props: CallClientProviderProps) => JSX.Element;

// @public
export interface CallClientProviderProps {
    // (undocumented)
    callClient: StatefulCallClient;
    // (undocumented)
    children: React_2.ReactNode;
}

// @public
export interface CallClientState {
    alternateCallerId?: string;
    callAgent?: CallAgentState;
    calls: {
        [key: string]: CallState;
    };
    callsEnded: {
        [key: string]: CallState;
    };
    deviceManager: DeviceManagerState;
    environmentInfo?: EnvironmentInfo;
    incomingCalls: {
        [key: string]: IncomingCallState;
    };
    incomingCallsEnded: {
        [key: string]: IncomingCallState;
    };
    latestErrors: CallErrors;
    userId: CommunicationIdentifierKind;
}

// @public
export const CallComposite: (props: CallCompositeProps) => JSX.Element;

// @public
export type CallCompositeIcons = {
    ControlButtonCameraOff?: JSX.Element;
    ControlButtonCameraOn?: JSX.Element;
    ControlButtonEndCall?: JSX.Element;
    ControlButtonMicOff?: JSX.Element;
    ControlButtonMicOn?: JSX.Element;
    ControlButtonOptions?: JSX.Element;
    ControlButtonParticipants?: JSX.Element;
    ControlButtonScreenShareStart?: JSX.Element;
    ControlButtonScreenShareStop?: JSX.Element;
    ErrorBarCallCameraAccessDenied?: JSX.Element;
    ErrorBarCallCameraAlreadyInUse?: JSX.Element;
    ErrorBarCallLocalVideoFreeze?: JSX.Element;
    ErrorBarCallMacOsCameraAccessDenied?: JSX.Element;
    ErrorBarCallMacOsMicrophoneAccessDenied?: JSX.Element;
    ErrorBarCallMicrophoneAccessDenied?: JSX.Element;
    ErrorBarCallMicrophoneMutedBySystem?: JSX.Element;
    ErrorBarCallMicrophoneUnmutedBySystem?: JSX.Element;
    ErrorBarCallNetworkQualityLow?: JSX.Element;
    ErrorBarCallNoMicrophoneFound?: JSX.Element;
    ErrorBarCallNoSpeakerFound?: JSX.Element;
    ErrorBarClear?: JSX.Element;
    HorizontalGalleryLeftButton?: JSX.Element;
    HorizontalGalleryRightButton?: JSX.Element;
    LobbyScreenConnectingToCall?: JSX.Element;
    LobbyScreenWaitingToBeAdmitted?: JSX.Element;
    LocalDeviceSettingsCamera?: JSX.Element;
    LocalDeviceSettingsMic?: JSX.Element;
    LocalDeviceSettingsSpeaker?: JSX.Element;
    LocalPreviewPlaceholder?: JSX.Element;
    Muted?: JSX.Element;
    NetworkReconnectIcon?: JSX.Element;
    NoticePageAccessDeniedTeamsMeeting?: JSX.Element;
    NoticePageJoinCallFailedDueToNoNetwork?: JSX.Element;
    NoticePageLeftCall?: JSX.Element;
    NoticePageRemovedFromCall?: JSX.Element;
    OptionsCamera?: JSX.Element;
    OptionsMic?: JSX.Element;
    OptionsSpeaker?: JSX.Element;
    ParticipantItemMicOff?: JSX.Element;
    ParticipantItemOptions?: JSX.Element;
    ParticipantItemOptionsHovered?: JSX.Element;
    ParticipantItemScreenShareStart?: JSX.Element;
    VideoTileMicOff?: JSX.Element;
    LocalCameraSwitch?: JSX.Element;
    PeoplePaneAddPerson?: JSX.Element;
    PeoplePaneOpenDialpad?: JSX.Element;
    DialpadStartCall?: JSX.Element;
    NoticePageInvalidRoom?: JSX.Element;
};

// @public
export type CallCompositeOptions = {
    errorBar?: boolean;
    callControls?: boolean | CallControlOptions;
    devicePermissions?: DevicePermissionRestrictions;
    callReadinessOptedIn?: boolean;
    onPermissionsTroubleshootingClick?: (permissionsState: {
        camera: PermissionState;
        microphone: PermissionState;
    }) => void;
    onNetworkingTroubleShootingClick?: () => void;
    onEnvironmentInfoTroubleshootingClick?: () => void;
};

// @public
export type CallCompositePage = 'accessDeniedTeamsMeeting' | 'call' | 'configuration' | /* @conditional-compile-remove(PSTN-calls) */ 'hold' | 'joinCallFailedDueToNoNetwork' | 'leftCall' | 'lobby' | /* @conditional-compile-remove(rooms) */ 'deniedPermissionToRoom' | 'removedFromCall' | /* @conditional-compile-remove(rooms) */ 'roomNotFound' | /* @conditional-compile-remove(unsupported-browser) */ 'unsupportedEnvironment';

// @public
export interface CallCompositeProps extends BaseCompositeProps<CallCompositeIcons> {
    adapter: CallAdapter;
    callInvitationUrl?: string;
    formFactor?: 'desktop' | 'mobile';
    options?: CallCompositeOptions;
}

// @public
export interface CallCompositeStrings {
    cameraLabel: string;
    cameraPermissionDenied: string;
    cameraTurnedOff: string;
    chatButtonLabel: string;
    close: string;
    complianceBannerNowOnlyRecording: string;
    complianceBannerNowOnlyTranscription: string;
    complianceBannerRecordingAndTranscriptionSaved: string;
    complianceBannerRecordingAndTranscriptionStarted: string;
    complianceBannerRecordingAndTranscriptionStopped: string;
    complianceBannerRecordingSaving: string;
    complianceBannerRecordingStarted: string;
    complianceBannerRecordingStopped: string;
    complianceBannerTranscriptionConsent: string;
    complianceBannerTranscriptionSaving: string;
    complianceBannerTranscriptionStarted: string;
    complianceBannerTranscriptionStopped: string;
    configurationPageCallDetails?: string;
    configurationPageTitle: string;
    copyInviteLinkActionedAriaLabel: string;
    copyInviteLinkButtonLabel: string;
    defaultPlaceHolder: string;
    deniedPermissionToRoomDetails?: string;
    deniedPermissionToRoomTitle: string;
    dialpadCloseModalButtonAriaLabel: string;
    dialpadModalAriaLabel: string;
    dialpadModalTitle: string;
    dialpadStartCallButtonLabel: string;
    dismissSidePaneButtonLabel?: string;
    dtmfDialpadPlaceholderText: string;
    failedToJoinCallDueToNoNetworkMoreDetails?: string;
    failedToJoinCallDueToNoNetworkTitle: string;
    failedToJoinTeamsMeetingReasonAccessDeniedMoreDetails?: string;
    failedToJoinTeamsMeetingReasonAccessDeniedTitle: string;
    holdScreenLabel: string;
    learnMore: string;
    leftCallMoreDetails?: string;
    leftCallTitle: string;
    lobbyScreenConnectingToCallMoreDetails?: string;
    lobbyScreenConnectingToCallTitle: string;
    lobbyScreenWaitingToBeAdmittedMoreDetails?: string;
    lobbyScreenWaitingToBeAdmittedTitle: string;
    microphonePermissionDenied: string;
    microphoneToggleInLobbyNotAllowed: string;
    moreButtonCallingLabel: string;
    mutedMessage: string;
    networkReconnectMoreDetails: string;
    networkReconnectTitle: string;
    openDialpadButtonLabel: string;
    openDtmfDialpadLabel: string;
    outboundCallingNoticeString: string;
    peopleButtonLabel: string;
    peopleButtonTooltipClose: string;
    peopleButtonTooltipOpen: string;
    peoplePaneAddPeopleButtonLabel: string;
    peoplePaneSubTitle: string;
    peoplePaneTitle: string;
    privacyPolicy: string;
    rejoinCallButtonLabel: string;
    removedFromCallMoreDetails?: string;
    removedFromCallTitle: string;
    removeMenuLabel: string;
    resumeCallButtonAriaLabel: string;
    resumeCallButtonLabel: string;
    resumingCallButtonAriaLabel: string;
    resumingCallButtonLabel: string;
    returnToCallButtonAriaDescription?: string;
    returnToCallButtonAriaLabel?: string;
    roomNotFoundDetails?: string;
    roomNotFoundTitle: string;
    soundLabel: string;
    startCallButtonLabel: string;
}

// @public
export type CallControlDisplayType = 'default' | 'compact';

// @public
export type CallControlOptions = {
    displayType?: CallControlDisplayType;
    cameraButton?: boolean | /* @conditional-compile-remove(PSTN-calls) */ {
        disabled: boolean;
    };
    endCallButton?: boolean;
    microphoneButton?: boolean | /* @conditional-compile-remove(PSTN-calls) */ {
        disabled: boolean;
    };
    devicesButton?: boolean | /* @conditional-compile-remove(PSTN-calls) */ {
        disabled: boolean;
    };
    participantsButton?: boolean | {
        disabled: boolean;
    };
    screenShareButton?: boolean | {
        disabled: boolean;
    };
    moreButton?: boolean;
    onFetchCustomButtonProps?: CustomCallControlButtonCallback[];
    holdButton?: boolean | {
        disabled: boolean;
    };
};

// @public
export type CallEndedListener = (event: CallAdapterCallEndedEvent) => void;

// @public
export class CallError extends Error {
    constructor(target: CallErrorTarget, innerError: Error, timestamp?: Date);
    innerError: Error;
    target: CallErrorTarget;
    timestamp: Date;
}

// @public
export type CallErrorBarSelector = (state: CallClientState, props: CallingBaseSelectorProps) => {
    activeErrorMessages: ActiveErrorMessage[];
};

// @public
export type CallErrors = {
    [target in CallErrorTarget]: CallError;
};

// @public
export type CallErrorTarget = 'Call.addParticipant' | /* @conditional-compile-remove(calling-beta-sdk) */ 'Call.dispose' | 'Call.feature' | 'Call.hangUp' | 'Call.hold' | 'Call.mute' | /* @conditional-compile-remove(calling-beta-sdk) */ 'Call.muteIncomingAudio' | 'Call.off' | 'Call.on' | 'Call.removeParticipant' | 'Call.resume' | 'Call.sendDtmf' | /* @conditional-compile-remove(calling-beta-sdk) */ 'Call.startAudio' | 'Call.startScreenSharing' | 'Call.startVideo' | 'Call.stopScreenSharing' | /* @conditional-compile-remove(calling-beta-sdk) */ 'Call.stopAudio' | 'Call.stopVideo' | 'Call.unmute' | /* @conditional-compile-remove(calling-beta-sdk) */ 'Call.unmuteIncomingAudio' | 'CallAgent.dispose' | 'CallAgent.feature' | 'CallAgent.join' | 'CallAgent.off' | 'CallAgent.on' | 'CallAgent.startCall' | 'CallClient.createCallAgent' | /* @conditional-compile-remove(calling-beta-sdk) */ /* @conditional-compile-remove(teams-identity-support) */ 'CallClient.createTeamsCallAgent' | 'CallClient.feature' | 'CallClient.getDeviceManager' | /* @conditional-compile-remove(calling-beta-sdk) */ 'CallClient.getEnvironmentInfo' | 'DeviceManager.askDevicePermission' | 'DeviceManager.getCameras' | 'DeviceManager.getMicrophones' | 'DeviceManager.getSpeakers' | 'DeviceManager.off' | 'DeviceManager.on' | 'DeviceManager.selectMicrophone' | 'DeviceManager.selectSpeaker' | 'IncomingCall.accept' | 'IncomingCall.reject' | /* @conditional-compile-remove(calling-beta-sdk) */ /* @conditional-compile-remove(teams-identity-support) */ 'TeamsCall.addParticipant';

// @public
export type CallIdChangedListener = (event: {
    callId: string;
}) => void;

// @public
export type CallingBaseSelectorProps = {
    callId: string;
};

// @public
export interface CallingHandlers extends CommonCallingHandlers {
    // (undocumented)
    onStartCall: (participants: CommunicationIdentifier[], options?: StartCallOptions) => Call | undefined;
}

// @public
export type CallingReturnProps<Component extends (props: any) => JSX.Element> = GetCallingSelector<Component> extends (state: CallClientState, props: any) => any ? ReturnType<GetCallingSelector<Component>> & Common<CallingHandlers, Parameters<Component>[0]> : never;

// @public
export interface CallingTheme {
    // (undocumented)
    callingPalette: {
        callRed: string;
        callRedDark: string;
        callRedDarker: string;
        iconWhite: string;
    };
}

// @public
export type CallParticipantListParticipant = ParticipantListParticipant & {
    state: ParticipantState;
    isScreenSharing?: boolean;
    isMuted?: boolean;
    isSpeaking?: boolean;
    role?: Role;
};

// @beta
export type CallParticipantsLocator = {
    participantIds: string[];
};

// @public
export const CallProvider: (props: CallProviderProps) => JSX.Element;

// @public
export interface CallProviderProps {
    // (undocumented)
    call?: Call | /* @conditional-compile-remove(teams-identity-support) */ TeamsCall;
    // (undocumented)
    children: React_2.ReactNode;
}

// @public
export interface CallState {
    callEndReason?: CallEndReason;
    callerInfo: CallerInfo;
    diagnostics: DiagnosticsCallFeatureState;
    direction: CallDirection;
    dominantSpeakers?: DominantSpeakersInfo;
    endTime: Date | undefined;
    id: string;
    isMuted: boolean;
    isScreenSharingOn: boolean;
    localVideoStreams: LocalVideoStreamState[];
    recording: RecordingCallFeature;
    remoteParticipants: {
        [keys: string]: RemoteParticipantState;
    };
    remoteParticipantsEnded: {
        [keys: string]: RemoteParticipantState;
    };
    role?: ParticipantRole;
    screenShareRemoteParticipant?: string;
    startTime: Date;
    state: CallState_2;
    transcription: TranscriptionCallFeature;
    type: 'Teams' | 'ACS';
}

// @public
export interface CallWithChatAdapter extends CallWithChatAdapterManagement, AdapterState<CallWithChatAdapterState>, Disposable, CallWithChatAdapterSubscriptions {
}

// @public
export interface CallWithChatAdapterManagement {
    // @beta
    addParticipant(participant: PhoneNumberIdentifier, options?: AddPhoneNumberOptions): Promise<void>;
    // (undocumented)
    addParticipant(participant: CommunicationUserIdentifier): Promise<void>;
    askDevicePermission(constrain: PermissionConstraints): Promise<void>;
    // @beta (undocumented)
    cancelFileUpload: (id: string) => void;
    // @beta (undocumented)
    clearFileUploads: () => void;
    createStreamView(remoteUserId?: string, options?: VideoStreamOptions): Promise<void | CreateVideoStreamViewResult>;
    deleteMessage(messageId: string): Promise<void>;
    disposeStreamView(remoteUserId?: string, options?: VideoStreamOptions): Promise<void>;
    fetchInitialData(): Promise<void>;
    // @beta
    holdCall: () => Promise<void>;
    joinCall(microphoneOn?: boolean): Call | undefined;
    leaveCall(forEveryone?: boolean): Promise<void>;
    loadPreviousChatMessages(messagesToLoad: number): Promise<boolean>;
    mute(): Promise<void>;
    queryCameras(): Promise<VideoDeviceInfo[]>;
    queryMicrophones(): Promise<AudioDeviceInfo[]>;
    querySpeakers(): Promise<AudioDeviceInfo[]>;
    // @beta (undocumented)
    registerActiveFileUploads: (files: File[]) => FileUploadManager[];
    // @beta (undocumented)
    registerCompletedFileUploads: (metadata: FileMetadata[]) => FileUploadManager[];
    removeParticipant(userId: string): Promise<void>;
    // @beta
    removeParticipant(participant: CommunicationIdentifier): Promise<void>;
    // @beta
    resumeCall: () => Promise<void>;
    // @beta
    sendDtmfTone: (dtmfTone: DtmfTone_2) => Promise<void>;
    sendMessage(content: string, options?: SendMessageOptions): Promise<void>;
    sendReadReceipt(chatMessageId: string): Promise<void>;
    sendTypingIndicator(): Promise<void>;
    setCamera(sourceInfo: VideoDeviceInfo, options?: VideoStreamOptions): Promise<void>;
    setMicrophone(sourceInfo: AudioDeviceInfo): Promise<void>;
    setSpeaker(sourceInfo: AudioDeviceInfo): Promise<void>;
    startCall(participants: string[], options?: StartCallOptions): Call | undefined;
    // @beta
    startCall(participants: CommunicationIdentifier[], options?: StartCallOptions): Call | undefined;
    startCamera(options?: VideoStreamOptions): Promise<void>;
    startScreenShare(): Promise<void>;
    stopCamera(): Promise<void>;
    stopScreenShare(): Promise<void>;
    unmute(): Promise<void>;
    // @beta (undocumented)
    updateFileUploadErrorMessage: (id: string, errorMessage: string) => void;
    // @beta (undocumented)
    updateFileUploadMetadata: (id: string, metadata: FileMetadata) => void;
    // @beta (undocumented)
    updateFileUploadProgress: (id: string, progress: number) => void;
    updateMessage(messageId: string, content: string, metadata?: Record<string, string>): Promise<void>;
}

// @public
export interface CallWithChatAdapterState extends CallWithChatAdapterUiState, CallWithChatClientState {
}

// @public
export interface CallWithChatAdapterSubscriptions {
    // (undocumented)
    off(event: 'callEnded', listener: CallEndedListener): void;
    // (undocumented)
    off(event: 'isMutedChanged', listener: IsMutedChangedListener): void;
    // (undocumented)
    off(event: 'callIdChanged', listener: CallIdChangedListener): void;
    // (undocumented)
    off(event: 'isLocalScreenSharingActiveChanged', listener: IsLocalScreenSharingActiveChangedListener): void;
    // (undocumented)
    off(event: 'displayNameChanged', listener: DisplayNameChangedListener): void;
    // (undocumented)
    off(event: 'isSpeakingChanged', listener: IsSpeakingChangedListener): void;
    // (undocumented)
    off(event: 'callParticipantsJoined', listener: ParticipantsJoinedListener): void;
    // (undocumented)
    off(event: 'callParticipantsLeft', listener: ParticipantsLeftListener): void;
    // (undocumented)
    off(event: 'selectedMicrophoneChanged', listener: PropertyChangedEvent): void;
    // (undocumented)
    off(event: 'selectedSpeakerChanged', listener: PropertyChangedEvent): void;
    // (undocumented)
    off(event: 'callError', listener: (e: AdapterError) => void): void;
    // (undocumented)
    off(event: 'messageReceived', listener: MessageReceivedListener): void;
    // (undocumented)
    off(event: 'messageSent', listener: MessageSentListener): void;
    // (undocumented)
    off(event: 'messageRead', listener: MessageReadListener): void;
    // (undocumented)
    off(event: 'chatParticipantsAdded', listener: ParticipantsAddedListener): void;
    // (undocumented)
    off(event: 'chatParticipantsRemoved', listener: ParticipantsRemovedListener): void;
    // (undocumented)
    off(event: 'chatError', listener: (e: AdapterError) => void): void;
    // (undocumented)
    on(event: 'callEnded', listener: CallEndedListener): void;
    // (undocumented)
    on(event: 'isMutedChanged', listener: IsMutedChangedListener): void;
    // (undocumented)
    on(event: 'callIdChanged', listener: CallIdChangedListener): void;
    // (undocumented)
    on(event: 'isLocalScreenSharingActiveChanged', listener: IsLocalScreenSharingActiveChangedListener): void;
    // (undocumented)
    on(event: 'displayNameChanged', listener: DisplayNameChangedListener): void;
    // (undocumented)
    on(event: 'isSpeakingChanged', listener: IsSpeakingChangedListener): void;
    // (undocumented)
    on(event: 'callParticipantsJoined', listener: ParticipantsJoinedListener): void;
    // (undocumented)
    on(event: 'callParticipantsLeft', listener: ParticipantsLeftListener): void;
    // (undocumented)
    on(event: 'selectedMicrophoneChanged', listener: PropertyChangedEvent): void;
    // (undocumented)
    on(event: 'selectedSpeakerChanged', listener: PropertyChangedEvent): void;
    // (undocumented)
    on(event: 'callError', listener: (e: AdapterError) => void): void;
    // (undocumented)
    on(event: 'messageReceived', listener: MessageReceivedListener): void;
    // (undocumented)
    on(event: 'messageSent', listener: MessageSentListener): void;
    // (undocumented)
    on(event: 'messageRead', listener: MessageReadListener): void;
    // (undocumented)
    on(event: 'chatParticipantsAdded', listener: ParticipantsAddedListener): void;
    // (undocumented)
    on(event: 'chatParticipantsRemoved', listener: ParticipantsRemovedListener): void;
    // (undocumented)
    on(event: 'chatError', listener: (e: AdapterError) => void): void;
}

// @public
export interface CallWithChatAdapterUiState {
    // @beta
    fileUploads?: FileUploadsUiState;
    isLocalPreviewMicrophoneEnabled: boolean;
    page: CallCompositePage;
}

// @public
export interface CallWithChatClientState {
    alternateCallerId?: string | undefined;
    call?: CallState;
    chat?: ChatThreadClientState;
    devices: DeviceManagerState;
    displayName: string | undefined;
    environmentInfo?: EnvironmentInfo;
    isTeamsCall: boolean;
    latestCallErrors: AdapterErrors;
    latestChatErrors: AdapterErrors;
    userId: CommunicationIdentifierKind;
}

// @public
export const CallWithChatComposite: (props: CallWithChatCompositeProps) => JSX.Element;

// @public
export type CallWithChatCompositeIcons = {
    ChevronLeft?: JSX.Element;
    ControlBarChatButtonActive?: JSX.Element;
    ControlBarChatButtonInactive?: JSX.Element;
    ControlBarPeopleButton?: JSX.Element;
    Link?: JSX.Element;
    MoreDrawerMicrophones?: JSX.Element;
    MoreDrawerPeople?: JSX.Element;
    MoreDrawerSelectedMicrophone?: JSX.Element;
    MoreDrawerSelectedSpeaker?: JSX.Element;
    MoreDrawerSpeakers?: JSX.Element;
    ControlButtonCameraOff?: JSX.Element;
    ControlButtonCameraOn?: JSX.Element;
    ControlButtonEndCall?: JSX.Element;
    ControlButtonMicOff?: JSX.Element;
    ControlButtonMicOn?: JSX.Element;
    ControlButtonOptions?: JSX.Element;
    ControlButtonScreenShareStart?: JSX.Element;
    ControlButtonScreenShareStop?: JSX.Element;
    ErrorBarCallCameraAccessDenied?: JSX.Element;
    ErrorBarCallCameraAlreadyInUse?: JSX.Element;
    ErrorBarCallLocalVideoFreeze?: JSX.Element;
    ErrorBarCallMacOsCameraAccessDenied?: JSX.Element;
    ErrorBarCallMacOsMicrophoneAccessDenied?: JSX.Element;
    ErrorBarCallMicrophoneAccessDenied?: JSX.Element;
    ErrorBarCallMicrophoneMutedBySystem?: JSX.Element;
    ErrorBarCallMicrophoneUnmutedBySystem?: JSX.Element;
    ErrorBarCallNetworkQualityLow?: JSX.Element;
    ErrorBarCallNoMicrophoneFound?: JSX.Element;
    ErrorBarCallNoSpeakerFound?: JSX.Element;
    ErrorBarClear?: JSX.Element;
    HorizontalGalleryLeftButton?: JSX.Element;
    HorizontalGalleryRightButton?: JSX.Element;
    LobbyScreenConnectingToCall?: JSX.Element;
    LobbyScreenWaitingToBeAdmitted?: JSX.Element;
    LocalDeviceSettingsCamera?: JSX.Element;
    LocalDeviceSettingsMic?: JSX.Element;
    LocalDeviceSettingsSpeaker?: JSX.Element;
    LocalPreviewPlaceholder?: JSX.Element;
    Muted?: JSX.Element;
    NetworkReconnectIcon?: JSX.Element;
    NoticePageAccessDeniedTeamsMeeting?: JSX.Element;
    NoticePageJoinCallFailedDueToNoNetwork?: JSX.Element;
    NoticePageLeftCall?: JSX.Element;
    NoticePageRemovedFromCall?: JSX.Element;
    OptionsCamera?: JSX.Element;
    OptionsMic?: JSX.Element;
    OptionsSpeaker?: JSX.Element;
    ParticipantItemMicOff?: JSX.Element;
    ParticipantItemScreenShareStart?: JSX.Element;
    VideoTileMicOff?: JSX.Element;
    LocalCameraSwitch?: JSX.Element;
    PeoplePaneAddPerson?: JSX.Element;
    PeoplePaneOpenDialpad?: JSX.Element;
    DialpadStartCall?: JSX.Element;
    EditBoxCancel?: JSX.Element;
    EditBoxSubmit?: JSX.Element;
    MessageDelivered?: JSX.Element;
    MessageEdit?: JSX.Element;
    MessageFailed?: JSX.Element;
    MessageRemove?: JSX.Element;
    MessageSeen?: JSX.Element;
    MessageSending?: JSX.Element;
    SendBoxSend?: JSX.Element;
    SendBoxSendHovered?: JSX.Element;
    SendBoxAttachFile?: JSX.Element;
    ParticipantItemOptions?: JSX.Element;
    ParticipantItemOptionsHovered?: JSX.Element;
};

// @public
export type CallWithChatCompositeOptions = {
    callControls?: boolean | CallWithChatControlOptions;
    fileSharing?: FileSharingOptions;
    devicePermissions?: DevicePermissionRestrictions;
    onPermissionsTroubleshootingClick?: (permissionsState: {
        camera: PermissionState;
        microphone: PermissionState;
    }) => void;
    onNetworkingTroubleShootingClick?: () => void;
    callReadinessOptedIn?: boolean;
};

// @public
export interface CallWithChatCompositeProps extends BaseCompositeProps<CallWithChatCompositeIcons> {
    // (undocumented)
    adapter: CallWithChatAdapter;
    fluentTheme?: PartialTheme | Theme;
    formFactor?: 'desktop' | 'mobile';
    joinInvitationURL?: string;
    options?: CallWithChatCompositeOptions;
}

// @public
export interface CallWithChatCompositeStrings {
    chatButtonLabel: string;
    chatButtonNewMessageNotificationLabel: string;
    chatButtonTooltipClose: string;
    chatButtonTooltipClosedWithMessageCount: string;
    chatButtonTooltipOpen: string;
    chatPaneTitle: string;
    copyInviteLinkActionedAriaLabel: string;
    copyInviteLinkButtonLabel: string;
    dialpadCloseModalButtonAriaLabel: string;
    dialpadModalAriaLabel: string;
    dialpadModalTitle: string;
    dialpadStartCallButtonLabel: string;
    dismissSidePaneButtonLabel?: string;
    dtmfDialpadPlaceholderText: string;
    moreDrawerAudioDeviceMenuTitle?: string;
    moreDrawerButtonLabel: string;
    moreDrawerButtonTooltip: string;
    moreDrawerMicrophoneMenuTitle: string;
    moreDrawerSpeakerMenuTitle: string;
    openDialpadButtonLabel: string;
    openDtmfDialpadLabel: string;
    peopleButtonLabel: string;
    peopleButtonTooltipClose: string;
    peopleButtonTooltipOpen: string;
    peoplePaneAddPeopleButtonLabel: string;
    peoplePaneSubTitle: string;
    peoplePaneTitle: string;
    pictureInPictureTileAriaLabel: string;
    removeMenuLabel: string;
    returnToCallButtonAriaDescription?: string;
    returnToCallButtonAriaLabel?: string;
}

// @public
export interface CallWithChatControlOptions {
    cameraButton?: boolean | /* @conditional-compile-remove(PSTN-calls) */ {
        disabled: boolean;
    };
    chatButton?: boolean | /* @conditional-compile-remove(PSTN-calls) */ {
        disabled: boolean;
    };
    displayType?: CallControlDisplayType;
    endCallButton?: boolean;
    holdButton?: boolean | {
        disabled: boolean;
    };
    microphoneButton?: boolean | /* @conditional-compile-remove(PSTN-calls) */ {
        disabled: boolean;
    };
    moreButton?: boolean;
    // @beta
    onFetchCustomButtonProps?: CustomCallWithChatControlButtonCallback[];
    peopleButton?: boolean | /* @conditional-compile-remove(PSTN-calls) */ {
        disabled: boolean;
    };
    screenShareButton?: boolean | {
        disabled: boolean;
    };
}

// @public
export type CallWithChatEvent = 'callError' | 'chatError' | 'callEnded' | 'isMutedChanged' | 'callIdChanged' | 'isLocalScreenSharingActiveChanged' | 'displayNameChanged' | 'isSpeakingChanged' | 'callParticipantsJoined' | 'callParticipantsLeft' | 'selectedMicrophoneChanged' | 'selectedSpeakerChanged' | 'messageReceived' | 'messageSent' | 'messageRead' | 'chatParticipantsAdded' | 'chatParticipantsRemoved';

// @beta
export const CameraAndMicrophoneDomainPermissions: (props: CameraAndMicrophoneDomainPermissionsProps) => JSX.Element;

// @beta
export interface CameraAndMicrophoneDomainPermissionsProps extends CommonDomainPermissionsProps {
    cameraIconName?: string;
    connectorIconName?: string;
    microphoneIconName?: string;
    strings?: CameraAndMicrophoneDomainPermissionsStrings;
}

// @beta
export type CameraAndMicrophoneDomainPermissionsStrings = DomainPermissionsStrings;

// @public
export const CameraButton: (props: CameraButtonProps) => JSX.Element;

// @public
export interface CameraButtonContextualMenuStyles extends IContextualMenuStyles {
    menuItemStyles?: IContextualMenuItemStyles;
}

// @public
export interface CameraButtonProps extends ControlBarButtonProps {
    cameras?: OptionsDevice[];
    enableDeviceSelectionMenu?: boolean;
    localVideoViewOptions?: VideoStreamOptions;
    onSelectCamera?: (device: OptionsDevice) => Promise<void>;
    onToggleCamera?: (options?: VideoStreamOptions) => Promise<void>;
    selectedCamera?: OptionsDevice;
    strings?: Partial<CameraButtonStrings>;
    styles?: Partial<CameraButtonStyles>;
}

// @public
export type CameraButtonSelector = (state: CallClientState, props: CallingBaseSelectorProps) => {
    disabled: boolean;
    checked: boolean;
    cameras: VideoDeviceInfo[];
    selectedCamera?: VideoDeviceInfo;
};

// @public
export interface CameraButtonStrings {
    cameraActionTurnedOffAnnouncement?: string;
    cameraActionTurnedOnAnnouncement?: string;
    cameraButtonSplitRoleDescription?: string;
    cameraMenuTitle: string;
    cameraMenuTooltip: string;
    offLabel: string;
    offSplitButtonAriaLabel?: string;
    onLabel: string;
    onSplitButtonAriaLabel?: string;
    tooltipDisabledContent?: string;
    tooltipOffContent?: string;
    tooltipOnContent?: string;
    tooltipVideoLoadingContent?: string;
}

// @public
export interface CameraButtonStyles extends ControlBarButtonStyles {
    menuStyles?: Partial<CameraButtonContextualMenuStyles>;
}

// @beta
export const CameraDomainPermissions: (props: CameraDomainPermissionsProps) => JSX.Element;

// @beta
export interface CameraDomainPermissionsProps extends CommonDomainPermissionsProps {
    cameraIconName?: string;
    strings?: CameraDomainPermissionsStrings;
}

// @beta
export type CameraDomainPermissionsStrings = DomainPermissionsStrings;

// @public
export type ChatAdapter = ChatAdapterThreadManagement & AdapterState<ChatAdapterState> & Disposable & ChatAdapterSubscribers & FileUploadAdapter;

// @public
export type ChatAdapterState = ChatAdapterUiState & ChatCompositeClientState;

// @public
export interface ChatAdapterSubscribers {
    off(event: 'messageReceived', listener: MessageReceivedListener): void;
    off(event: 'messageSent', listener: MessageSentListener): void;
    off(event: 'messageRead', listener: MessageReadListener): void;
    off(event: 'participantsAdded', listener: ParticipantsAddedListener): void;
    off(event: 'participantsRemoved', listener: ParticipantsRemovedListener): void;
    off(event: 'topicChanged', listener: TopicChangedListener): void;
    off(event: 'error', listener: (e: AdapterError) => void): void;
    on(event: 'messageReceived', listener: MessageReceivedListener): void;
    on(event: 'messageSent', listener: MessageSentListener): void;
    on(event: 'messageRead', listener: MessageReadListener): void;
    on(event: 'participantsAdded', listener: ParticipantsAddedListener): void;
    on(event: 'participantsRemoved', listener: ParticipantsRemovedListener): void;
    on(event: 'topicChanged', listener: TopicChangedListener): void;
    on(event: 'error', listener: (e: AdapterError) => void): void;
}

// @public
export interface ChatAdapterThreadManagement {
    deleteMessage(messageId: string): Promise<void>;
    fetchInitialData(): Promise<void>;
    loadPreviousChatMessages(messagesToLoad: number): Promise<boolean>;
    removeParticipant(userId: string): Promise<void>;
    sendMessage(content: string, options?: SendMessageOptions): Promise<void>;
    sendReadReceipt(chatMessageId: string): Promise<void>;
    sendTypingIndicator(): Promise<void>;
    setTopic(topicName: string): Promise<void>;
    updateMessage(messageId: string, content: string, metadata?: Record<string, string>, options?: {
        attachedFilesMetadata?: FileMetadata[];
    }): Promise<void>;
}

// @public
export type ChatAdapterUiState = {
    error?: Error;
    fileUploads?: FileUploadsUiState;
};

// @public
export type ChatBaseSelectorProps = {
    threadId: string;
};

// @public
export const ChatClientProvider: (props: ChatClientProviderProps) => JSX.Element;

// @public
export type ChatClientProviderProps = {
    children: React_2.ReactNode;
    chatClient: StatefulChatClient;
};

// @public
export type ChatClientState = {
    userId: CommunicationIdentifierKind;
    displayName: string;
    threads: {
        [key: string]: ChatThreadClientState;
    };
    latestErrors: ChatErrors;
};

// @public
export const ChatComposite: (props: ChatCompositeProps) => JSX.Element;

// @public
export type ChatCompositeClientState = {
    userId: CommunicationIdentifierKind;
    displayName: string;
    thread: ChatThreadClientState;
    latestErrors: AdapterErrors;
};

// @public
export type ChatCompositeIcons = {
    EditBoxCancel?: JSX.Element;
    EditBoxSubmit?: JSX.Element;
    MessageDelivered?: JSX.Element;
    MessageEdit?: JSX.Element;
    MessageFailed?: JSX.Element;
    MessageRemove?: JSX.Element;
    MessageSeen?: JSX.Element;
    MessageSending?: JSX.Element;
    ParticipantItemOptions?: JSX.Element;
    ParticipantItemOptionsHovered?: JSX.Element;
    SendBoxSend?: JSX.Element;
    SendBoxSendHovered?: JSX.Element;
    SendBoxAttachFile?: JSX.Element;
};

// @public
export type ChatCompositeOptions = {
    errorBar?: boolean;
    participantPane?: boolean;
    topic?: boolean;
    autoFocus?: 'sendBoxTextField';
    fileSharing?: FileSharingOptions;
};

// @public
export interface ChatCompositeProps extends BaseCompositeProps<ChatCompositeIcons> {
    adapter: ChatAdapter;
    formFactor?: 'desktop' | 'mobile';
    onRenderMessage?: (messageProps: MessageProps, defaultOnRender?: MessageRenderer) => JSX.Element;
    onRenderTypingIndicator?: (typingUsers: CommunicationParticipant[]) => JSX.Element;
    options?: ChatCompositeOptions;
}

// @public
export interface ChatCompositeStrings {
    chatListHeader: string;
    uploadFile: string;
}

// @public
export class ChatError extends Error {
    constructor(target: ChatErrorTarget, innerError: Error, timestamp?: Date);
    innerError: Error;
    target: ChatErrorTarget;
    timestamp: Date;
}

// @public
export type ChatErrorBarSelector = (state: ChatClientState, props: ChatBaseSelectorProps) => {
    activeErrorMessages: ActiveErrorMessage[];
};

// @public
export type ChatErrors = {
    [target in ChatErrorTarget]: ChatError;
};

// @public
export type ChatErrorTarget = 'ChatClient.createChatThread' | 'ChatClient.deleteChatThread' | 'ChatClient.getChatThreadClient' | 'ChatClient.listChatThreads' | 'ChatClient.off' | 'ChatClient.on' | 'ChatClient.startRealtimeNotifications' | 'ChatClient.stopRealtimeNotifications' | 'ChatThreadClient.addParticipants' | 'ChatThreadClient.deleteMessage' | 'ChatThreadClient.getMessage' | 'ChatThreadClient.getProperties' | 'ChatThreadClient.listMessages' | 'ChatThreadClient.listParticipants' | 'ChatThreadClient.listReadReceipts' | 'ChatThreadClient.removeParticipant' | 'ChatThreadClient.sendMessage' | 'ChatThreadClient.sendReadReceipt' | 'ChatThreadClient.sendTypingNotification' | 'ChatThreadClient.updateMessage' | 'ChatThreadClient.updateTopic';

// @public
export type ChatHandlers = {
    onSendMessage: (content: string, options?: SendMessageOptions) => Promise<void>;
    onMessageSeen: (chatMessageId: string) => Promise<void>;
    onTyping: () => Promise<void>;
    onRemoveParticipant: (userId: string) => Promise<void>;
    updateThreadTopicName: (topicName: string) => Promise<void>;
    onLoadPreviousChatMessages: (messagesToLoad: number) => Promise<boolean>;
    onUpdateMessage: (messageId: string, content: string, metadata?: Record<string, string>, options?: {
        attachedFilesMetadata?: FileMetadata[];
    }) => Promise<void>;
    onDeleteMessage: (messageId: string) => Promise<void>;
};

// @public
export interface ChatMessage extends MessageCommon {
    // (undocumented)
    attached?: MessageAttachedStatus;
    // @beta
    attachedFilesMetadata?: FileMetadata[];
    // (undocumented)
    clientMessageId?: string;
    // (undocumented)
    content?: string;
    // (undocumented)
    contentType: MessageContentType;
    // (undocumented)
    deletedOn?: Date;
    // (undocumented)
    editedOn?: Date;
    // (undocumented)
    messageType: 'chat';
    metadata?: Record<string, string>;
    // (undocumented)
    mine?: boolean;
    // (undocumented)
    senderDisplayName?: string;
    // (undocumented)
    senderId?: string;
    // (undocumented)
    status?: MessageStatus;
}

// @public
export type ChatMessageWithStatus = ChatMessage_2 & {
    clientMessageId?: string;
    status: MessageStatus;
};

// @public
export type ChatParticipantListSelector = (state: ChatClientState, props: ChatBaseSelectorProps) => {
    myUserId: string;
    participants: ParticipantListParticipant[];
};

// @public
export type ChatReturnProps<Component extends (props: any) => JSX.Element> = GetChatSelector<Component> extends (state: ChatClientState, props: any) => any ? ReturnType<GetChatSelector<Component>> & Common<ChatHandlers, Parameters<Component>[0]> : never;

// @public
export const ChatThreadClientProvider: (props: ChatThreadClientProviderProps) => JSX.Element;

// @public
export type ChatThreadClientProviderProps = {
    children: React_2.ReactNode;
    chatThreadClient: ChatThreadClient;
};

// @public
export type ChatThreadClientState = {
    chatMessages: {
        [key: string]: ChatMessageWithStatus;
    };
    participants: {
        [key: string]: ChatParticipant;
    };
    threadId: string;
    properties?: ChatThreadProperties;
    readReceipts: ChatMessageReadReceipt[];
    typingIndicators: TypingIndicatorReceivedEvent[];
    latestReadTime: Date;
};

// @public
export type ChatThreadProperties = {
    topic?: string;
};

// @public
export type ClientState = CallClientState & ChatClientState;

// @public
export type Common<A, B> = Pick<A, CommonProperties<A, B>>;

// @public
export interface CommonCallingHandlers {
    // (undocumented)
    askDevicePermission: (constrain: PermissionConstraints) => Promise<void>;
    // (undocumented)
    onAddParticipant(participant: CommunicationUserIdentifier): Promise<void>;
    // (undocumented)
    onAddParticipant(participant: PhoneNumberIdentifier, options: AddPhoneNumberOptions): Promise<void>;
    // (undocumented)
    onCreateLocalStreamView: (options?: VideoStreamOptions) => Promise<void | CreateVideoStreamViewResult>;
    // (undocumented)
    onCreateRemoteStreamView: (userId: string, options?: VideoStreamOptions) => Promise<void | CreateVideoStreamViewResult>;
    // (undocumented)
    onDisposeLocalStreamView: () => Promise<void>;
    // (undocumented)
    onDisposeRemoteStreamView: (userId: string) => Promise<void>;
    // (undocumented)
    onHangUp: (forEveryone?: boolean) => Promise<void>;
    // (undocumented)
    onRemoveParticipant(userId: string): Promise<void>;
    // (undocumented)
    onRemoveParticipant(participant: CommunicationIdentifier): Promise<void>;
    // (undocumented)
    onSelectCamera: (device: VideoDeviceInfo, options?: VideoStreamOptions) => Promise<void>;
    // (undocumented)
    onSelectMicrophone: (device: AudioDeviceInfo) => Promise<void>;
    // (undocumented)
    onSelectSpeaker: (device: AudioDeviceInfo) => Promise<void>;
    // (undocumented)
    onSendDtmfTone: (dtmfTone: DtmfTone_2) => Promise<void>;
    // (undocumented)
    onStartCall: (participants: (CommunicationUserIdentifier | PhoneNumberIdentifier | UnknownIdentifier)[], options?: StartCallOptions) => void;
    // (undocumented)
    onStartLocalVideo: () => Promise<void>;
    // (undocumented)
    onStartScreenShare: () => Promise<void>;
    // (undocumented)
    onStopScreenShare: () => Promise<void>;
    // (undocumented)
    onToggleCamera: (options?: VideoStreamOptions) => Promise<void>;
    // (undocumented)
    onToggleHold: () => Promise<void>;
    // (undocumented)
    onToggleMicrophone: () => Promise<void>;
    // (undocumented)
    onToggleScreenShare: () => Promise<void>;
}

// @beta
export interface CommonDomainPermissionsProps {
    appName: string;
    onContinueAnywayClick?: () => void;
    onTroubleshootingClick?: () => void;
    styles?: DomainPermissionsStyles;
    type: 'request' | 'denied' | 'check';
}

// @public
export type CommonProperties<A, B> = {
    [P in keyof A & keyof B]: A[P] extends B[P] ? P : never;
}[keyof A & keyof B];

// @public
export type CommunicationParticipant = {
    userId: string;
    displayName?: string;
};

// @public
export const COMPONENT_LOCALE_DE_DE: ComponentLocale;

// @public
export const COMPONENT_LOCALE_EN_GB: ComponentLocale;

// @public
export const COMPONENT_LOCALE_EN_US: ComponentLocale;

// @public
export const COMPONENT_LOCALE_ES_ES: ComponentLocale;

// @public
export const COMPONENT_LOCALE_FR_FR: ComponentLocale;

// @public
export const COMPONENT_LOCALE_IT_IT: ComponentLocale;

// @public
export const COMPONENT_LOCALE_JA_JP: ComponentLocale;

// @public
export const COMPONENT_LOCALE_KO_KR: ComponentLocale;

// @public
export const COMPONENT_LOCALE_NL_NL: ComponentLocale;

// @public
export const COMPONENT_LOCALE_PT_BR: ComponentLocale;

// @public
export const COMPONENT_LOCALE_RU_RU: ComponentLocale;

// @public
export const COMPONENT_LOCALE_TR_TR: ComponentLocale;

// @public
export const COMPONENT_LOCALE_ZH_CN: ComponentLocale;

// @public
export const COMPONENT_LOCALE_ZH_TW: ComponentLocale;

// @public
export type ComponentIcons = Record<keyof typeof DEFAULT_COMPONENT_ICONS, JSX.Element>;

// @public
export interface ComponentLocale {
    // @beta
    onDisplayDateTimeString?: (messageDate: Date) => string;
    strings: ComponentStrings;
}

// @public
export type ComponentProps<Component extends (props: any) => JSX.Element> = ChatReturnProps<Component> extends never ? CallingReturnProps<Component> extends never ? undefined : CallingReturnProps<Component> : ChatReturnProps<Component>;

// @public
export interface ComponentStrings {
    BrowserPermissionDenied: BrowserPermissionDeniedStrings;
    BrowserPermissionDeniedIOS: BrowserPermissionDeniedIOSStrings;
    CameraAndMicrophoneDomainPermissionsCheck: DomainPermissionsStrings;
    CameraAndMicrophoneDomainPermissionsDenied: DomainPermissionsStrings;
    CameraAndMicrophoneDomainPermissionsRequest: DomainPermissionsStrings;
    cameraButton: CameraButtonStrings;
    CameraDomainPermissionsCheck: DomainPermissionsStrings;
    CameraDomainPermissionsDenied: DomainPermissionsStrings;
    CameraDomainPermissionsRequest: DomainPermissionsStrings;
    devicesButton: DevicesButtonStrings;
    dialpad: DialpadStrings;
    endCallButton: EndCallButtonStrings;
    errorBar: ErrorBarStrings;
    holdButton: HoldButtonStrings;
    messageStatusIndicator: MessageStatusIndicatorStrings;
    messageThread: MessageThreadStrings;
    microphoneButton: MicrophoneButtonStrings;
    MicrophoneDomainPermissionsCheck: DomainPermissionsStrings;
    MicrophoneDomainPermissionsDenied: DomainPermissionsStrings;
    MicrophoneDomainPermissionsRequest: DomainPermissionsStrings;
    participantItem: ParticipantItemStrings;
    participantsButton: ParticipantsButtonStrings;
    screenShareButton: ScreenShareButtonStrings;
    sendBox: SendBoxStrings;
    typingIndicator: TypingIndicatorStrings;
    UnsupportedBrowser: UnsupportedBrowserStrings;
    videoGallery: VideoGalleryStrings;
    videoTile: VideoTileStrings;
}

// @public
export const COMPOSITE_LOCALE_DE_DE: CompositeLocale;

// @public
export const COMPOSITE_LOCALE_EN_GB: CompositeLocale;

// @public
export const COMPOSITE_LOCALE_EN_US: CompositeLocale;

// @public
export const COMPOSITE_LOCALE_ES_ES: CompositeLocale;

// @public
export const COMPOSITE_LOCALE_FR_FR: CompositeLocale;

// @public
export const COMPOSITE_LOCALE_IT_IT: CompositeLocale;

// @public
export const COMPOSITE_LOCALE_JA_JP: CompositeLocale;

// @public
export const COMPOSITE_LOCALE_KO_KR: CompositeLocale;

// @public
export const COMPOSITE_LOCALE_NL_NL: CompositeLocale;

// @public
export const COMPOSITE_LOCALE_PT_BR: CompositeLocale;

// @public
export const COMPOSITE_LOCALE_RU_RU: CompositeLocale;

// @public
export const COMPOSITE_LOCALE_TR_TR: CompositeLocale;

// @public
export const COMPOSITE_LOCALE_ZH_CN: CompositeLocale;

// @public
export const COMPOSITE_LOCALE_ZH_TW: CompositeLocale;

// @public
export const COMPOSITE_ONLY_ICONS: CompositeIcons;

// @public
export type CompositeIcons = ChatCompositeIcons & CallCompositeIcons & CallWithChatCompositeIcons;

// @public
export interface CompositeLocale {
    component: ComponentLocale;
    strings: CompositeStrings;
}

// @public
export interface CompositeStrings {
    call: CallCompositeStrings;
    callWithChat: CallWithChatCompositeStrings;
    chat: ChatCompositeStrings;
}

// @public
export interface ContentSystemMessage extends SystemMessageCommon {
    // (undocumented)
    content: string;
    // (undocumented)
    systemMessageType: 'content';
}

// @public
export const ControlBar: (props: ControlBarProps) => JSX.Element;

// @public
export const ControlBarButton: (props: ControlBarButtonProps) => JSX.Element;

// @public
export interface ControlBarButtonProps extends IButtonProps {
    labelKey?: string;
    onRenderOffIcon?: IRenderFunction<IButtonProps>;
    onRenderOnIcon?: IRenderFunction<IButtonProps>;
    showLabel?: boolean;
    strings?: ControlBarButtonStrings;
    styles?: ControlBarButtonStyles;
    tooltipId?: string;
}

// @public
export interface ControlBarButtonStrings {
    label?: string;
    offLabel?: string;
    onLabel?: string;
    tooltipContent?: string;
    tooltipDisabledContent?: string;
    tooltipOffContent?: string;
    tooltipOnContent?: string;
}

// @public
export type ControlBarButtonStyles = IButtonStyles;

// @public
export type ControlBarLayout = 'horizontal' | 'vertical' | 'dockedTop' | 'dockedBottom' | 'dockedLeft' | 'dockedRight' | 'floatingTop' | 'floatingBottom' | 'floatingLeft' | 'floatingRight';

// @public
export interface ControlBarProps {
    children?: React_2.ReactNode;
    layout?: ControlBarLayout;
    styles?: BaseCustomStyles;
}

// @public
export const createAzureCommunicationCallAdapter: ({ userId, displayName, credential, locator, alternateCallerId, options }: AzureCommunicationCallAdapterArgs) => Promise<CallAdapter>;

// @public
export const createAzureCommunicationCallAdapterFromClient: (callClient: StatefulCallClient, callAgent: CallAgent, locator: CallAdapterLocator, options?: AzureCommunicationCallAdapterOptions) => Promise<CallAdapter>;

// @public
export const createAzureCommunicationCallWithChatAdapter: ({ userId, displayName, credential, endpoint, locator, alternateCallerId, callAdapterOptions }: AzureCommunicationCallWithChatAdapterArgs) => Promise<CallWithChatAdapter>;

// @public
export const createAzureCommunicationCallWithChatAdapterFromClients: ({ callClient, callAgent, callLocator, chatClient, chatThreadClient }: AzureCommunicationCallWithChatAdapterFromClientArgs) => Promise<CallWithChatAdapter>;

// @public
export const createAzureCommunicationChatAdapter: ({ endpoint: endpointUrl, userId, displayName, credential, threadId }: AzureCommunicationChatAdapterArgs) => Promise<ChatAdapter>;

// @public
export const createAzureCommunicationChatAdapterFromClient: (chatClient: StatefulChatClient, chatThreadClient: ChatThreadClient) => Promise<ChatAdapter>;

// @public
export const createDefaultCallingHandlers: (callClient: StatefulCallClient, callAgent: CallAgent | undefined, deviceManager: StatefulDeviceManager | undefined, call: Call | undefined) => CallingHandlers;

// @public
export const createDefaultChatHandlers: (chatClient: StatefulChatClient, chatThreadClient: ChatThreadClient) => ChatHandlers;

// @beta
export const createDefaultTeamsCallingHandlers: (callClient: StatefulCallClient, callAgent: undefined | /* @conditional-compile-remove(teams-identity-support) */ TeamsCallAgent, deviceManager: StatefulDeviceManager | undefined, call: undefined | /* @conditional-compile-remove(teams-identity-support) */ TeamsCall) => never | TeamsCallingHandlers;

// @public
export const createStatefulCallClient: (args: StatefulCallClientArgs, options?: StatefulCallClientOptions | undefined) => StatefulCallClient;

// @public
export const createStatefulChatClient: (args: StatefulChatClientArgs, options?: StatefulChatClientOptions | undefined) => StatefulChatClient;

// @public
export interface CreateVideoStreamViewResult {
    view: {
        updateScalingMode: (scalingMode: ViewScalingMode) => Promise<void>;
    };
}

// @public
export type CreateViewResult = {
    renderer: VideoStreamRenderer;
    view: VideoStreamRendererView;
};

// @public
export type CustomAvatarOptions = {
    coinSize?: number;
    hidePersonaDetails?: boolean;
    initialsTextColor?: string;
    noVideoAvailableAriaLabel?: string;
    presence?: PersonaPresence;
    size?: PersonaSize;
    styles?: IStyleFunctionOrObject<IPersonaStyleProps, IPersonaStyles>;
    text?: string;
    participantState?: ParticipantState;
    showUnknownPersonaCoin?: boolean;
};

// @beta
export type CustomCallControlButtonCallback = (args: CustomCallControlButtonCallbackArgs) => CustomCallControlButtonProps;

// @beta
export interface CustomCallControlButtonCallbackArgs {
    displayType?: CallControlDisplayType;
}

// @beta
export type CustomCallControlButtonPlacement = 'primary';

// @beta
export interface CustomCallControlButtonProps extends CustomControlButtonProps {
    iconName?: string;
    placement: CustomCallControlButtonPlacement;
}

// @beta
export type CustomCallWithChatControlButtonCallback = (args: CustomCallControlButtonCallbackArgs) => CustomCallWithChatControlButtonProps;

// @beta
export type CustomCallWithChatControlButtonPlacement = 'primary' | 'overflow' | 'secondary';

// @beta
export interface CustomCallWithChatControlButtonProps extends CustomControlButtonProps {
    iconName?: string;
    placement: CustomCallWithChatControlButtonPlacement;
}

// @beta
export interface CustomControlButtonProps {
    ariaDescription?: string;
    ariaLabel?: string;
    disabled?: boolean;
    id?: string;
    key?: string | number;
    onItemClick?: () => void;
    showLabel?: boolean;
    styles?: ControlBarButtonStyles | BaseCustomStyles;
    text?: string;
}

// @public
export interface CustomMessage extends MessageCommon {
    // (undocumented)
    content: string;
    // (undocumented)
    messageType: 'custom';
}

// @public
export const darkTheme: PartialTheme & CallingTheme;

// @beta
export type DeclarativeCallAgent = CallAgent & IncomingCallManagement;

// @beta
export type DeclarativeIncomingCall = IncomingCall;

// @public
export const DEFAULT_COMPONENT_ICONS: {
    ChatMessageOptions: JSX.Element;
    ControlButtonCameraOff: JSX.Element;
    ControlButtonCameraOn: JSX.Element;
    ControlButtonEndCall: JSX.Element;
    ControlButtonMicOff: JSX.Element;
    ControlButtonMicOn: JSX.Element;
    ControlButtonOptions: JSX.Element;
    ControlButtonParticipants: JSX.Element;
    ControlButtonParticipantsContextualMenuItem: JSX.Element;
    ControlButtonScreenShareStart: JSX.Element;
    ControlButtonScreenShareStop: JSX.Element;
    CancelFileUpload: JSX.Element;
    DownloadFile: JSX.Element;
    EditBoxCancel: JSX.Element;
    EditBoxSubmit: JSX.Element;
    ErrorBarCallCameraAccessDenied: JSX.Element;
    ErrorBarCallCameraAlreadyInUse: JSX.Element;
    ErrorBarCallLocalVideoFreeze: JSX.Element;
    ErrorBarCallMacOsCameraAccessDenied: JSX.Element;
    ErrorBarCallMacOsMicrophoneAccessDenied: JSX.Element;
    ErrorBarCallMicrophoneAccessDenied: JSX.Element;
    ErrorBarCallMicrophoneMutedBySystem: JSX.Element;
    ErrorBarCallMicrophoneUnmutedBySystem: JSX.Element;
    ErrorBarCallNetworkQualityLow: JSX.Element;
    ErrorBarCallNoMicrophoneFound: JSX.Element;
    ErrorBarCallNoSpeakerFound: JSX.Element;
    ErrorBarClear: JSX.Element;
    ErrorBarCallVideoRecoveredBySystem: JSX.Element;
    ErrorBarCallVideoStoppedBySystem: JSX.Element;
    HorizontalGalleryLeftButton: JSX.Element;
    HorizontalGalleryRightButton: JSX.Element;
    MessageDelivered: JSX.Element;
    MessageEdit: JSX.Element;
    MessageFailed: JSX.Element;
    MessageRemove: JSX.Element;
    MessageResend: JSX.Element;
    MessageSeen: JSX.Element;
    MessageSending: JSX.Element;
    OptionsCamera: JSX.Element;
    OptionsMic: JSX.Element;
    OptionsSpeaker: JSX.Element;
    ParticipantItemMicOff: JSX.Element;
    ParticipantItemOptions: JSX.Element;
    ParticipantItemOptionsHovered: JSX.Element;
    ParticipantItemScreenShareStart: JSX.Element;
    HoldCallContextualMenuItem: JSX.Element;
    HoldCallButton: JSX.Element;
    ResumeCall: JSX.Element;
    SendBoxSend: JSX.Element;
    SendBoxSendHovered: JSX.Element;
    VideoTileMicOff: JSX.Element;
    DialpadBackspace: JSX.Element;
    DomainPermissionsSparkle: JSX.Element;
    DomainPermissionCamera: JSX.Element;
    DomainPermissionMic: JSX.Element;
    DomainPermissionCameraDenied: JSX.Element;
    DomainPermissionMicDenied: JSX.Element;
    UnsupportedBrowserWarning: JSX.Element;
    BrowserPermissionDeniedError: JSX.Element;
    VideoTilePinned: JSX.Element;
};

// @public
export const DEFAULT_COMPOSITE_ICONS: {
    EditBoxCancel: JSX.Element;
    EditBoxSubmit: JSX.Element;
    MessageDelivered: JSX.Element;
    MessageEdit: JSX.Element;
    MessageFailed: JSX.Element;
    MessageRemove: JSX.Element;
    MessageSeen: JSX.Element;
    MessageSending: JSX.Element;
    ParticipantItemOptions: JSX.Element;
    ParticipantItemOptionsHovered: JSX.Element;
    SendBoxSend: JSX.Element;
    SendBoxSendHovered: JSX.Element;
    SendBoxAttachFile?: JSX.Element | undefined;
    ControlButtonCameraOff: JSX.Element;
    ControlButtonCameraOn: JSX.Element;
    ControlButtonEndCall: JSX.Element;
    ControlButtonMicOff: JSX.Element;
    ControlButtonMicOn: JSX.Element;
    ControlButtonOptions: JSX.Element;
    ControlButtonParticipants: JSX.Element;
    ControlButtonScreenShareStart: JSX.Element;
    ControlButtonScreenShareStop: JSX.Element;
    ErrorBarCallCameraAccessDenied: JSX.Element;
    ErrorBarCallCameraAlreadyInUse: JSX.Element;
    ErrorBarCallLocalVideoFreeze: JSX.Element;
    ErrorBarCallMacOsCameraAccessDenied: JSX.Element;
    ErrorBarCallMacOsMicrophoneAccessDenied: JSX.Element;
    ErrorBarCallMicrophoneAccessDenied: JSX.Element;
    ErrorBarCallMicrophoneMutedBySystem: JSX.Element;
    ErrorBarCallMicrophoneUnmutedBySystem: JSX.Element;
    ErrorBarCallNetworkQualityLow: JSX.Element;
    ErrorBarCallNoMicrophoneFound: JSX.Element;
    ErrorBarCallNoSpeakerFound: JSX.Element;
    ErrorBarClear: JSX.Element;
    HorizontalGalleryLeftButton: JSX.Element;
    HorizontalGalleryRightButton: JSX.Element;
    LobbyScreenConnectingToCall?: JSX.Element | undefined;
    LobbyScreenWaitingToBeAdmitted?: JSX.Element | undefined;
    LocalDeviceSettingsCamera?: JSX.Element | undefined;
    LocalDeviceSettingsMic?: JSX.Element | undefined;
    LocalDeviceSettingsSpeaker?: JSX.Element | undefined;
    LocalPreviewPlaceholder?: JSX.Element | undefined;
    Muted?: JSX.Element | undefined;
    NetworkReconnectIcon?: JSX.Element | undefined;
    NoticePageAccessDeniedTeamsMeeting?: JSX.Element | undefined;
    NoticePageJoinCallFailedDueToNoNetwork?: JSX.Element | undefined;
    NoticePageLeftCall?: JSX.Element | undefined;
    NoticePageRemovedFromCall?: JSX.Element | undefined;
    OptionsCamera: JSX.Element;
    OptionsMic: JSX.Element;
    OptionsSpeaker: JSX.Element;
    ParticipantItemMicOff: JSX.Element;
    ParticipantItemScreenShareStart: JSX.Element;
    VideoTileMicOff: JSX.Element;
    LocalCameraSwitch?: JSX.Element | undefined;
    PeoplePaneAddPerson?: JSX.Element | undefined;
    PeoplePaneOpenDialpad?: JSX.Element | undefined;
    DialpadStartCall?: JSX.Element | undefined;
    NoticePageInvalidRoom?: JSX.Element | undefined;
    ChevronLeft?: JSX.Element | undefined;
    ControlBarChatButtonActive?: JSX.Element | undefined;
    ControlBarChatButtonInactive?: JSX.Element | undefined;
    ControlBarPeopleButton?: JSX.Element | undefined;
    Link?: JSX.Element | undefined;
    MoreDrawerMicrophones?: JSX.Element | undefined;
    MoreDrawerPeople?: JSX.Element | undefined;
    MoreDrawerSelectedMicrophone?: JSX.Element | undefined;
    MoreDrawerSelectedSpeaker?: JSX.Element | undefined;
    MoreDrawerSpeakers?: JSX.Element | undefined;
    ChatMessageOptions: JSX.Element;
    ControlButtonParticipantsContextualMenuItem: JSX.Element;
    CancelFileUpload: JSX.Element;
    DownloadFile: JSX.Element;
    ErrorBarCallVideoRecoveredBySystem: JSX.Element;
    ErrorBarCallVideoStoppedBySystem: JSX.Element;
    MessageResend: JSX.Element;
    HoldCallContextualMenuItem: JSX.Element;
    HoldCallButton: JSX.Element;
    ResumeCall: JSX.Element;
    DialpadBackspace: JSX.Element;
    DomainPermissionsSparkle: JSX.Element;
    DomainPermissionCamera: JSX.Element;
    DomainPermissionMic: JSX.Element;
    DomainPermissionCameraDenied: JSX.Element;
    DomainPermissionMicDenied: JSX.Element;
    UnsupportedBrowserWarning: JSX.Element;
    BrowserPermissionDeniedError: JSX.Element;
    VideoTilePinned: JSX.Element;
};

// @public
export type DeviceManagerState = {
    isSpeakerSelectionAvailable: boolean;
    selectedMicrophone?: AudioDeviceInfo;
    selectedSpeaker?: AudioDeviceInfo;
    selectedCamera?: VideoDeviceInfo;
    cameras: VideoDeviceInfo[];
    microphones: AudioDeviceInfo[];
    speakers: AudioDeviceInfo[];
    deviceAccess?: DeviceAccess;
    unparentedViews: LocalVideoStreamState[];
};

// @internal
export const _DevicePermissionDropdown: (props: _DevicePermissionDropdownProps) => JSX.Element;

// @internal
export interface _DevicePermissionDropdownProps {
    askDevicePermission?(constrain: _PermissionConstraints): Promise<void>;
    constrain?: _PermissionConstraints;
    icon?: JSX.Element;
    onClick?: () => void;
    options?: IDropdownOption[];
    strings?: _DevicePermissionDropdownStrings;
    styles?: Partial<IDropdownStyles>;
}

// @internal
export interface _DevicePermissionDropdownStrings {
    actionButtonContent?: string;
    label?: string;
    placeHolderText: string;
}

// @beta
export interface DevicePermissionRestrictions {
    camera: 'required' | 'optional' | 'doNotPrompt';
    microphone: 'required' | 'optional' | 'doNotPrompt';
}

// @public
export const DevicesButton: (props: DevicesButtonProps) => JSX.Element;

// @public
export interface DevicesButtonContextualMenuStyles extends IContextualMenuStyles {
    menuItemStyles?: IContextualMenuItemStyles;
}

// @public
export interface DevicesButtonProps extends ControlBarButtonProps {
    cameras?: OptionsDevice[];
    microphones?: OptionsDevice[];
    onSelectCamera?: (device: OptionsDevice) => Promise<void>;
    onSelectMicrophone?: (device: OptionsDevice) => Promise<void>;
    onSelectSpeaker?: (device: OptionsDevice) => Promise<void>;
    selectedCamera?: OptionsDevice;
    selectedMicrophone?: OptionsDevice;
    selectedSpeaker?: OptionsDevice;
    speakers?: OptionsDevice[];
    strings?: Partial<DevicesButtonStrings>;
    styles?: DevicesButtonStyles;
}

// @public
export type DevicesButtonSelector = (state: CallClientState, props: CallingBaseSelectorProps) => {
    microphones: AudioDeviceInfo[];
    speakers: AudioDeviceInfo[];
    cameras: VideoDeviceInfo[];
    selectedMicrophone?: AudioDeviceInfo;
    selectedSpeaker?: AudioDeviceInfo;
    selectedCamera?: VideoDeviceInfo;
};

// @public
export interface DevicesButtonStrings {
    cameraMenuTitle: string;
    cameraMenuTooltip: string;
    label: string;
    microphoneMenuTitle: string;
    microphoneMenuTooltip: string;
    speakerMenuTitle: string;
    speakerMenuTooltip: string;
    tooltipContent?: string;
}

// @public
export interface DevicesButtonStyles extends ControlBarButtonStyles {
    menuStyles?: Partial<DevicesButtonContextualMenuStyles>;
}

// @public
export type DiagnosticChangedEventListner = (event: MediaDiagnosticChangedEvent | NetworkDiagnosticChangedEvent) => void;

// @public
export interface DiagnosticsCallFeatureState {
    media: MediaDiagnosticsState;
    network: NetworkDiagnosticsState;
}

// @beta
export const Dialpad: (props: DialpadProps) => JSX.Element;

// @beta
export interface DialpadProps {
    isMobile?: boolean;
    onChange?: (input: string) => void;
    onClickDialpadButton?: (buttonValue: string, buttonIndex: number) => void;
    onSendDtmfTone?: (dtmfTone: DtmfTone) => Promise<void>;
    showDeleteButton?: boolean;
    // (undocumented)
    strings?: DialpadStrings;
    // (undocumented)
    styles?: DialpadStyles;
    textFieldValue?: string;
}

// @beta
export interface DialpadStrings {
    // (undocumented)
    deleteButtonAriaLabel?: string;
    // (undocumented)
    placeholderText: string;
}

// @beta
export interface DialpadStyles {
    // (undocumented)
    button?: IButtonStyles;
    // (undocumented)
    deleteIcon?: IButtonStyles;
    // (undocumented)
    digit?: IStyle;
    // (undocumented)
    letter?: IStyle;
    // (undocumented)
    root?: IStyle;
    // (undocumented)
    textField?: Partial<ITextFieldStyles>;
}

// @public
export type DisplayNameChangedListener = (event: {
    participantId: CommunicationIdentifierKind;
    displayName: string;
}) => void;

// @public
export interface Disposable {
    dispose(): void;
}

// @beta
export type DomainPermissionsStrings = {
    primaryText?: string;
    secondaryText?: string;
    linkText?: string;
    primaryButtonText?: string;
    ariaLabel?: string;
};

// @beta
export interface DomainPermissionsStyles extends BaseCustomStyles {
    primaryButton?: IButtonStyles;
    troubleshootingLink?: ILinkStyles;
}

// @beta
export type DtmfTone = 'A' | 'B' | 'C' | 'D' | 'Flash' | 'Num0' | 'Num1' | 'Num2' | 'Num3' | 'Num4' | 'Num5' | 'Num6' | 'Num7' | 'Num8' | 'Num9' | 'Pound' | 'Star';

// @public
export type EmptySelector = () => Record<string, never>;

// @public
export const EndCallButton: (props: EndCallButtonProps) => JSX.Element;

// @public
export interface EndCallButtonProps extends ControlBarButtonProps {
    onHangUp?: () => Promise<void>;
    strings?: EndCallButtonStrings;
}

// @public
export interface EndCallButtonStrings {
    label: string;
    tooltipContent?: string;
}

// @public
export const ErrorBar: (props: ErrorBarProps) => JSX.Element;

// @public
export interface ErrorBarProps extends IMessageBarProps {
    activeErrorMessages: ActiveErrorMessage[];
    ignorePremountErrors?: boolean;
    strings?: ErrorBarStrings;
}

// @public
export interface ErrorBarStrings {
    accessDenied: string;
    callCameraAccessDenied: string;
    callCameraAlreadyInUse: string;
    callLocalVideoFreeze: string;
    callMacOsCameraAccessDenied: string;
    callMacOsMicrophoneAccessDenied: string;
    callMacOsScreenShareAccessDenied: string;
    callMicrophoneAccessDenied: string;
    callMicrophoneMutedBySystem: string;
    callMicrophoneUnmutedBySystem: string;
    callNetworkQualityLow: string;
    callNoMicrophoneFound: string;
    callNoSpeakerFound: string;
    callVideoRecoveredBySystem: string;
    callVideoStoppedBySystem: string;
    dismissButtonAriaLabel?: string;
    failedToJoinCallGeneric?: string;
    failedToJoinCallInvalidMeetingLink?: string;
    muteGeneric: string;
    sendMessageGeneric: string;
    sendMessageNotInChatThread: string;
    startScreenShareGeneric: string;
    startVideoGeneric: string;
    stopScreenShareGeneric: string;
    stopVideoGeneric: string;
    unableToReachChatService: string;
    unmuteGeneric: string;
    userNotInChatThread: string;
}

// @public
export type ErrorType = keyof ErrorBarStrings;

// @beta
export interface FileDownloadError {
    errorMessage: string;
}

// @beta
export type FileDownloadHandler = (userId: string, fileMetadata: FileMetadata) => Promise<URL | FileDownloadError>;

// @beta
export interface FileMetadata {
    extension: string;
    name: string;
    url: string;
}

// @beta
export interface FileSharingOptions {
    accept?: string;
    downloadHandler?: FileDownloadHandler;
    multiple?: boolean;
    uploadHandler: FileUploadHandler;
}

// @beta (undocumented)
export interface FileUploadAdapter {
    // (undocumented)
    cancelFileUpload: (id: string) => void;
    // (undocumented)
    clearFileUploads: () => void;
    // (undocumented)
    registerActiveFileUploads: (files: File[]) => FileUploadManager[];
    // (undocumented)
    registerCompletedFileUploads: (metadata: FileMetadata[]) => FileUploadManager[];
    // (undocumented)
    updateFileUploadErrorMessage: (id: string, errorMessage: string) => void;
    // (undocumented)
    updateFileUploadMetadata: (id: string, metadata: FileMetadata) => void;
    // (undocumented)
    updateFileUploadProgress: (id: string, progress: number) => void;
}

// @beta
export type FileUploadError = {
    message: string;
    timestamp: number;
};

// @beta
export type FileUploadHandler = (userId: string, fileUploads: FileUploadManager[]) => void;

// @beta
export interface FileUploadManager {
    file?: File;
    id: string;
    notifyUploadCompleted: (metadata: FileMetadata) => void;
    notifyUploadFailed: (message: string) => void;
    notifyUploadProgressChanged: (value: number) => void;
}

// @beta
export interface FileUploadState {
    error?: FileUploadError;
    filename: string;
    id: string;
    metadata?: FileMetadata;
    progress: number;
}

// @beta
export type FileUploadsUiState = Record<string, FileUploadState>;

// @public
export const FluentThemeProvider: (props: FluentThemeProviderProps) => JSX.Element;

// @public
export interface FluentThemeProviderProps {
    children: React_2.ReactNode;
    fluentTheme?: PartialTheme | Theme;
    rtl?: boolean;
}

// @public
export const fromFlatCommunicationIdentifier: (id: string) => CommunicationIdentifier;

// @public
export type GetCallingSelector<Component extends (props: any) => JSX.Element | undefined> = AreEqual<Component, typeof VideoGallery> extends true ? VideoGallerySelector : AreEqual<Component, typeof DevicesButton> extends true ? DevicesButtonSelector : AreEqual<Component, typeof MicrophoneButton> extends true ? MicrophoneButtonSelector : AreEqual<Component, typeof CameraButton> extends true ? CameraButtonSelector : AreEqual<Component, typeof ScreenShareButton> extends true ? ScreenShareButtonSelector : AreEqual<Component, typeof ParticipantList> extends true ? ParticipantListSelector : AreEqual<Component, typeof ParticipantsButton> extends true ? ParticipantsButtonSelector : AreEqual<Component, typeof EndCallButton> extends true ? EmptySelector : AreEqual<Component, typeof ErrorBar> extends true ? CallErrorBarSelector : AreEqual<Component, typeof Dialpad> extends true ? EmptySelector : AreEqual<Component, typeof HoldButton> extends true ? HoldButtonSelector : AreEqual<Component, typeof _DevicePermissionDropdown> extends true ? EmptySelector : undefined;

// @public
export const getCallingSelector: <Component extends (props: any) => JSX.Element | undefined>(component: Component) => GetCallingSelector<Component>;

// @public
export type GetChatSelector<Component extends (props: any) => JSX.Element | undefined> = AreEqual<Component, typeof SendBox> extends true ? SendBoxSelector : AreEqual<Component, typeof MessageThread> extends true ? MessageThreadSelector : AreEqual<Component, typeof TypingIndicator> extends true ? TypingIndicatorSelector : AreEqual<Component, typeof ParticipantList> extends true ? ChatParticipantListSelector : AreEqual<Component, typeof ErrorBar> extends true ? ChatErrorBarSelector : undefined;

// @public
export const getChatSelector: <Component extends (props: any) => JSX.Element | undefined>(component: Component) => GetChatSelector<Component>;

// @public
export const GridLayout: (props: GridLayoutProps) => JSX.Element;

// @public
export interface GridLayoutProps {
    // (undocumented)
    children: React_2.ReactNode;
    styles?: BaseCustomStyles;
}

// @public
export interface GridLayoutStyles extends BaseCustomStyles {
    children?: IStyle;
}

// @beta
export const HoldButton: (props: HoldButtonProps) => JSX.Element;

// @beta (undocumented)
export interface HoldButtonProps extends ControlBarButtonProps {
    onToggleHold: () => Promise<void>;
    strings?: HoldButtonStrings;
}

// @public
export type HoldButtonSelector = (state: CallClientState, props: CallingBaseSelectorProps) => {
    checked: boolean;
};

// @beta
export interface HoldButtonStrings {
    offLabel: string;
    onLabel: string;
    tooltipOffContent: string;
    tooltipOnContent: string;
}

// @public
export interface HorizontalGalleryStyles extends BaseCustomStyles {
    children?: IStyle;
    nextButton?: IStyle;
    previousButton?: IStyle;
}

// @internal
export const _IdentifierProvider: (props: _IdentifierProviderProps) => JSX.Element;

// @internal
export interface _IdentifierProviderProps {
    // (undocumented)
    children: React_2.ReactNode;
    // (undocumented)
    identifiers?: _Identifiers;
}

// @internal
export interface _Identifiers {
    horizontalGalleryLeftNavButton: string;
    horizontalGalleryRightNavButton: string;
    messageContent: string;
    messageTimestamp: string;
    participantButtonPeopleMenuItem: string;
    participantItemMenuButton: string;
    participantList: string;
    participantListPeopleButton: string;
    participantListRemoveParticipantButton: string;
    sendboxTextField: string;
    typingIndicator: string;
    videoGallery: string;
    videoTile: string;
}

// @beta
export type IncomingCallManagement = {
    incomingCalls: ReadonlyArray<DeclarativeIncomingCall>;
};

// @public
export interface IncomingCallState {
    callEndReason?: CallEndReason;
    callerInfo: CallerInfo;
    endTime?: Date;
    id: string;
    startTime: Date;
}

// @public
export type IsLocalScreenSharingActiveChangedListener = (event: {
    isScreenSharingOn: boolean;
}) => void;

// @public
export type IsMutedChangedListener = (event: {
    identifier: CommunicationIdentifierKind;
    isMuted: boolean;
}) => void;

// @public
export type IsSpeakingChangedListener = (event: {
    identifier: CommunicationIdentifierKind;
    isSpeaking: boolean;
}) => void;

// @public
export interface JumpToNewMessageButtonProps {
    onClick: () => void;
    text: string;
}

// @public
export const lightTheme: PartialTheme & CallingTheme;

// @public
export type LoadingState = 'loading' | 'none';

// @public
export const LocalizationProvider: (props: LocalizationProviderProps) => JSX.Element;

// @public
export type LocalizationProviderProps = {
    locale: ComponentLocale;
    children: React_2.ReactNode;
};

// @public (undocumented)
export interface LocalVideoCameraCycleButtonProps {
    ariaDescription?: string;
    cameras?: OptionsDevice[];
    label?: string;
    onSelectCamera?: (device: OptionsDevice) => Promise<void>;
    selectedCamera?: OptionsDevice;
}

// @public
export interface LocalVideoStreamState {
    mediaStreamType: MediaStreamType;
    source: VideoDeviceInfo;
    view?: VideoStreamRendererViewState;
}

// @public
export type MediaDiagnosticChangedEvent = MediaDiagnosticChangedEventArgs & {
    type: 'media';
};

// @public
export interface MediaDiagnosticsState {
    // (undocumented)
    latest: LatestMediaDiagnostics;
}

// @public
export type Message = ChatMessage | SystemMessage | CustomMessage;

// @public
export type MessageAttachedStatus = 'bottom' | 'top' | boolean;

// @public
export interface MessageCommon {
    // (undocumented)
    createdOn: Date;
    // (undocumented)
    messageId: string;
}

// @public
export type MessageContentType = 'text' | 'html' | 'richtext/html' | 'unknown';

// @public
export type MessageProps = {
    message: Message;
    strings: MessageThreadStrings;
    messageContainerStyle?: ComponentSlotStyle;
    showDate?: boolean;
    disableEditing?: boolean;
    onUpdateMessage?: UpdateMessageCallback;
    onDeleteMessage?: (messageId: string) => Promise<void>;
    onSendMessage?: (messageId: string) => Promise<void>;
};

// @public
export type MessageReadListener = (event: {
    message: ChatMessage_2;
    readBy: CommunicationUserKind;
}) => void;

// @public
export type MessageReceivedListener = (event: {
    message: ChatMessage_2;
}) => void;

// @public
export type MessageRenderer = (props: MessageProps) => JSX.Element;

// @public
export type MessageSentListener = MessageReceivedListener;

// @public
export type MessageStatus = 'delivered' | 'sending' | 'seen' | 'failed';

// @public
export const MessageStatusIndicator: (props: MessageStatusIndicatorProps) => JSX.Element;

// @public
export interface MessageStatusIndicatorProps {
    // (undocumented)
    onToggleToolTip?: (isToggled: boolean) => void;
    // (undocumented)
    readCount?: number;
    remoteParticipantsCount?: number;
    status?: MessageStatus;
    strings?: MessageStatusIndicatorStrings;
    styles?: BaseCustomStyles;
}

// @public
export interface MessageStatusIndicatorStrings {
    deliveredAriaLabel?: string;
    deliveredTooltipText: string;
    failedToSendAriaLabel?: string;
    failedToSendTooltipText: string;
    readByTooltipText?: string;
    seenAriaLabel?: string;
    seenTooltipText: string;
    sendingAriaLabel?: string;
    sendingTooltipText: string;
}

// @public
export const MessageThread: (props: MessageThreadProps) => JSX.Element;

// @public
export type MessageThreadProps = {
    userId: string;
    messages: (ChatMessage | SystemMessage | CustomMessage)[];
    participantCount?: number;
    readReceiptsBySenderId?: ReadReceiptsBySenderId;
    styles?: MessageThreadStyles;
    disableJumpToNewMessageButton?: boolean;
    showMessageDate?: boolean;
    showMessageStatus?: boolean;
    numberOfChatMessagesToReload?: number;
    onMessageSeen?: (messageId: string) => Promise<void>;
    onRenderMessageStatus?: (messageStatusIndicatorProps: MessageStatusIndicatorProps) => JSX.Element | null;
    onRenderAvatar?: OnRenderAvatarCallback;
    onRenderJumpToNewMessageButton?: (newMessageButtonProps: JumpToNewMessageButtonProps) => JSX.Element;
    onLoadPreviousChatMessages?: (messagesToLoad: number) => Promise<boolean>;
    onRenderMessage?: (messageProps: MessageProps, messageRenderer?: MessageRenderer) => JSX.Element;
    onRenderFileDownloads?: (userId: string, message: ChatMessage) => JSX.Element;
    onUpdateMessage?: UpdateMessageCallback;
    onDeleteMessage?: (messageId: string) => Promise<void>;
    onSendMessage?: (messageId: string) => Promise<void>;
    disableEditing?: boolean;
    strings?: Partial<MessageThreadStrings>;
    fileDownloadHandler?: FileDownloadHandler;
    onDisplayDateTimeString?: (messageDate: Date) => string;
};

// @public
export type MessageThreadSelector = (state: ChatClientState, props: ChatBaseSelectorProps) => {
    userId: string;
    showMessageStatus: boolean;
    messages: Message[];
};

// @public
export interface MessageThreadStrings {
    actionMenuMoreOptions?: string;
    downloadFile: string;
    editBoxCancelButton: string;
    editBoxPlaceholderText: string;
    editBoxSubmitButton: string;
    editBoxTextLimit: string;
    editedTag: string;
    editMessage: string;
    failToSendTag?: string;
    friday: string;
    liveAuthorIntro: string;
    messageContentAriaText: string;
    messageContentMineAriaText: string;
    messageReadCount?: string;
    monday: string;
    newMessagesIndicator: string;
    noDisplayNameSub: string;
    participantJoined: string;
    participantLeft: string;
    removeMessage: string;
    resendMessage?: string;
    saturday: string;
    sunday: string;
    thursday: string;
    tuesday: string;
    wednesday: string;
    yesterday: string;
}

// @public
export interface MessageThreadStyles extends BaseCustomStyles {
    chatContainer?: ComponentSlotStyle;
    chatItemMessageContainer?: ComponentSlotStyle;
    chatMessageContainer?: ComponentSlotStyle;
    failedMyChatMessageContainer?: ComponentSlotStyle;
    loadPreviousMessagesButtonContainer?: IStyle;
    messageStatusContainer?: (mine: boolean) => IStyle;
    myChatItemMessageContainer?: ComponentSlotStyle;
    myChatMessageContainer?: ComponentSlotStyle;
    newMessageButtonContainer?: IStyle;
    systemMessageContainer?: ComponentSlotStyle;
}

// @public
export const MicrophoneButton: (props: MicrophoneButtonProps) => JSX.Element;

// @public
export interface MicrophoneButtonContextualMenuStyles extends IContextualMenuStyles {
    menuItemStyles?: IContextualMenuItemStyles;
}

// @public
export interface MicrophoneButtonProps extends ControlBarButtonProps {
    enableDeviceSelectionMenu?: boolean;
    microphones?: OptionsDevice[];
    onSelectMicrophone?: (device: OptionsDevice) => Promise<void>;
    onSelectSpeaker?: (device: OptionsDevice) => Promise<void>;
    onToggleMicrophone?: () => Promise<void>;
    selectedMicrophone?: OptionsDevice;
    selectedSpeaker?: OptionsDevice;
    speakers?: OptionsDevice[];
    strings?: Partial<MicrophoneButtonStrings>;
    styles?: Partial<MicrophoneButtonStyles>;
}

// @public
export type MicrophoneButtonSelector = (state: CallClientState, props: CallingBaseSelectorProps) => {
    disabled: boolean;
    checked: boolean;
    microphones: AudioDeviceInfo[];
    speakers: AudioDeviceInfo[];
    selectedMicrophone?: AudioDeviceInfo;
    selectedSpeaker?: AudioDeviceInfo;
};

// @public
export interface MicrophoneButtonStrings {
    microphoneActionTurnedOffAnnouncement?: string;
    microphoneActionTurnedOnAnnouncement?: string;
    microphoneButtonSplitRoleDescription?: string;
    microphoneMenuTitle?: string;
    microphoneMenuTooltip?: string;
    offLabel: string;
    offSplitButtonAriaLabel?: string;
    onLabel: string;
    onSplitButtonAriaLabel?: string;
    speakerMenuTitle?: string;
    speakerMenuTooltip?: string;
    tooltipDisabledContent?: string;
    tooltipOffContent?: string;
    tooltipOnContent?: string;
}

// @public
export interface MicrophoneButtonStyles extends ControlBarButtonStyles {
    menuStyles?: Partial<MicrophoneButtonContextualMenuStyles>;
}

// @beta
export const MicrophoneDomainPermissions: (props: MicrophoneDomainPermissionsProps) => JSX.Element;

// @beta
export interface MicrophoneDomainPermissionsProps extends CommonDomainPermissionsProps {
    microphoneIconName?: string;
    strings?: MicrophoneDomainPermissionsStrings;
}

// @beta
export type MicrophoneDomainPermissionsStrings = DomainPermissionsStrings;

// @public
export type NetworkDiagnosticChangedEvent = NetworkDiagnosticChangedEventArgs & {
    type: 'network';
};

// @public
export interface NetworkDiagnosticsState {
    // (undocumented)
    latest: LatestNetworkDiagnostics;
}

// @public
export type OnRenderAvatarCallback = (
userId?: string, options?: CustomAvatarOptions,
defaultOnRender?: (props: CustomAvatarOptions) => JSX.Element) => JSX.Element;

// @public
export interface OptionsDevice {
    id: string;
    name: string;
}

// @public
export interface ParticipantAddedSystemMessage extends SystemMessageCommon {
    // (undocumented)
    participants: CommunicationParticipant[];
    // (undocumented)
    systemMessageType: 'participantAdded';
}

// @public
export const ParticipantItem: (props: ParticipantItemProps) => JSX.Element;

// @public
export interface ParticipantItemProps {
    displayName?: string;
    me?: boolean;
    menuItems?: IContextualMenuItem[];
    onClick?: (props?: ParticipantItemProps) => void;
    onRenderAvatar?: OnRenderAvatarCallback;
    onRenderIcon?: (props?: ParticipantItemProps) => JSX.Element | null;
    participantState?: ParticipantState;
    presence?: PersonaPresence;
    showParticipantOverflowTooltip?: boolean;
    strings?: Partial<ParticipantItemStrings>;
    styles?: ParticipantItemStyles;
    userId?: string;
}

// @public
export interface ParticipantItemStrings {
    displayNamePlaceholder?: string;
    isMeText: string;
    menuTitle: string;
    mutedIconLabel: string;
    participantStateConnecting?: string;
    participantStateHold?: string;
    participantStateRinging?: string;
    removeButtonLabel: string;
    sharingIconLabel: string;
}

// @public
export interface ParticipantItemStyles extends BaseCustomStyles {
    avatar?: IStyle;
    iconContainer?: IStyle;
    me?: IStyle;
    menu?: IStyle;
}

// @public
export const ParticipantList: (props: ParticipantListProps) => JSX.Element;

// @public
export interface ParticipantListItemStyles extends ParticipantItemStyles {
    participantSubMenuItemsStyles?: IContextualMenuItemStyles;
}

// @public
export type ParticipantListParticipant = CommunicationParticipant & {
    isRemovable: boolean;
};

// @public
export type ParticipantListProps = {
    participants: ParticipantListParticipant[];
    myUserId?: string;
    excludeMe?: boolean;
    onRenderParticipant?: (participant: ParticipantListParticipant) => JSX.Element | null;
    onRenderAvatar?: OnRenderAvatarCallback;
    onRemoveParticipant?: (userId: string) => void;
    onFetchParticipantMenuItems?: ParticipantMenuItemsCallback;
    onParticipantClick?: (participant?: ParticipantListParticipant) => void;
    styles?: ParticipantListStyles;
    showParticipantOverflowTooltip?: boolean;
};

// @public
export type ParticipantListSelector = (state: CallClientState, props: CallingBaseSelectorProps) => {
    participants: CallParticipantListParticipant[];
    myUserId: string;
};

// @public
export interface ParticipantListStyles extends BaseCustomStyles {
    participantItemStyles?: ParticipantListItemStyles;
}

// @public
export type ParticipantMenuItemsCallback = (participantUserId: string, userId?: string, defaultMenuItems?: IContextualMenuItem[]) => IContextualMenuItem[];

// @public
export interface ParticipantRemovedSystemMessage extends SystemMessageCommon {
    // (undocumented)
    participants: CommunicationParticipant[];
    // (undocumented)
    systemMessageType: 'participantRemoved';
}

// @public
export type ParticipantsAddedListener = (event: {
    participantsAdded: ChatParticipant[];
    addedBy: ChatParticipant;
}) => void;

// @public
export const ParticipantsButton: (props: ParticipantsButtonProps) => JSX.Element;

// @public
export interface ParticipantsButtonContextualMenuStyles extends IContextualMenuStyles {
    menuItemStyles?: IContextualMenuItemStyles;
    participantListStyles?: ParticipantListStyles;
}

// @public
export interface ParticipantsButtonProps extends ControlBarButtonProps {
    callInvitationURL?: string;
    excludeMe?: boolean;
    myUserId?: string;
    onFetchParticipantMenuItems?: ParticipantMenuItemsCallback;
    onMuteAll?: () => void;
    onRemoveParticipant?: (userId: string) => void;
    onRenderAvatar?: OnRenderAvatarCallback;
    onRenderParticipant?: (participant: CommunicationParticipant) => JSX.Element | null;
    onRenderParticipantList?: (props: ParticipantListProps) => JSX.Element | null;
    participants: ParticipantListParticipant[];
    showParticipantOverflowTooltip?: boolean;
    strings?: Partial<ParticipantsButtonStrings>;
    styles?: ParticipantsButtonStyles;
}

// @public
export type ParticipantsButtonSelector = (state: CallClientState, props: CallingBaseSelectorProps) => {
    participants: CallParticipantListParticipant[];
    myUserId: string;
};

// @public
export interface ParticipantsButtonStrings {
    copyInviteLinkButtonLabel: string;
    label: string;
    menuHeader: string;
    muteAllButtonLabel: string;
    participantsListButtonLabel: string;
    tooltipContent?: string;
}

// @public
export interface ParticipantsButtonStyles extends ControlBarButtonStyles {
    menuStyles?: Partial<ParticipantsButtonContextualMenuStyles>;
}

// @public
export type ParticipantsJoinedListener = (event: {
    joined: RemoteParticipant[];
}) => void;

// @public
export type ParticipantsLeftListener = (event: {
    removed: RemoteParticipant[];
}) => void;

// @public
export type ParticipantsRemovedListener = (event: {
    participantsRemoved: ChatParticipant[];
    removedBy: ChatParticipant;
}) => void;

// @public
export type ParticipantState = 'Idle' | 'Connecting' | 'Ringing' | 'Connected' | 'Hold' | 'InLobby' | 'EarlyMedia' | 'Disconnected';

// @internal
export type _PermissionConstraints = {
    audio: boolean;
    video: boolean;
};

// @public
export type ReadReceiptsBySenderId = {
    [key: string]: {
        lastReadMessage: string;
        displayName: string;
    };
};

// @public
export interface RecordingCallFeature {
    isRecordingActive: boolean;
}

// @public
export interface RemoteParticipantState {
    callEndReason?: CallEndReason;
    displayName?: string;
    identifier: CommunicationUserKind | PhoneNumberKind | MicrosoftTeamsUserKind | UnknownIdentifierKind;
    isMuted: boolean;
    isSpeaking: boolean;
    role?: ParticipantRole;
    state: RemoteParticipantState_2;
    videoStreams: {
        [key: number]: RemoteVideoStreamState;
    };
}

// @public
export interface RemoteVideoStreamState {
    id: number;
    isAvailable: boolean;
    // @beta
    isReceiving: boolean;
    mediaStreamType: MediaStreamType;
    view?: VideoStreamRendererViewState;
}

// @beta
export type Role = 'Presenter' | 'Attendee' | 'Consumer' | 'Organizer';

// @public
export const ScreenShareButton: (props: ScreenShareButtonProps) => JSX.Element;

// @public
export interface ScreenShareButtonProps extends ControlBarButtonProps {
    onToggleScreenShare?: () => Promise<void>;
    strings?: Partial<ScreenShareButtonStrings>;
}

// @public
export type ScreenShareButtonSelector = (state: CallClientState, props: CallingBaseSelectorProps) => {
    checked?: boolean;
    disabled?: boolean;
};

// @public
export interface ScreenShareButtonStrings {
    offLabel: string;
    onLabel: string;
    tooltipDisabledContent?: string;
    tooltipOffContent?: string;
    tooltipOnContent?: string;
}

// @public
export type Selector = (state: ClientState, props: any) => any;

// @public
export const SendBox: (props: SendBoxProps) => JSX.Element;

// @beta
export interface SendBoxErrorBarError {
    message: string;
    timestamp: number;
}

// @public
export interface SendBoxProps {
    // @beta
    activeFileUploads?: ActiveFileUpload[];
    autoFocus?: 'sendBoxTextField';
    disabled?: boolean;
    // @beta
    onCancelFileUpload?: (fileId: string) => void;
    // @beta
    onRenderFileUploads?: () => JSX.Element;
    onRenderIcon?: (isHover: boolean) => JSX.Element;
    onRenderSystemMessage?: (systemMessage: string | undefined) => React_2.ReactElement;
    onSendMessage?: (content: string) => Promise<void>;
    onTyping?: () => Promise<void>;
    strings?: Partial<SendBoxStrings>;
    styles?: SendBoxStylesProps;
    supportNewline?: boolean;
    systemMessage?: string;
}

// @public
export type SendBoxSelector = (state: ChatClientState, props: ChatBaseSelectorProps) => {
    displayName: string;
    userId: string;
};

// @public
export interface SendBoxStrings {
    fileUploadsPendingError: string;
    placeholderText: string;
    removeFile: string;
    sendButtonAriaLabel: string;
    textTooLong: string;
    uploadCompleted: string;
    uploading: string;
}

// @public
export interface SendBoxStylesProps extends BaseCustomStyles {
    sendMessageIcon?: IStyle;
    sendMessageIconContainer?: IStyle;
    systemMessage?: IStyle;
    textField?: IStyle;
    textFieldContainer?: IStyle;
}

// @public
export interface StatefulCallClient extends CallClient {
    createCallAgent(...args: Parameters<CallClient['createCallAgent']>): Promise<DeclarativeCallAgent>;
    createView(callId: string | undefined, participantId: CommunicationIdentifier | undefined, stream: LocalVideoStreamState | RemoteVideoStreamState, options?: CreateViewOptions): Promise<CreateViewResult | undefined>;
    disposeView(callId: string | undefined, participantId: CommunicationIdentifier | undefined, stream: LocalVideoStreamState | RemoteVideoStreamState): void;
    getState(): CallClientState;
    offStateChange(handler: (state: CallClientState) => void): void;
    onStateChange(handler: (state: CallClientState) => void): void;
}

// @public
export type StatefulCallClientArgs = {
    userId: CommunicationUserIdentifier;
    alternateCallerId?: string;
};

// @public
export type StatefulCallClientOptions = {
    callClientOptions: CallClientOptions;
    maxStateChangeListeners?: number;
};

// @public
export interface StatefulChatClient extends ChatClient {
    getState(): ChatClientState;
    offStateChange(handler: (state: ChatClientState) => void): void;
    onStateChange(handler: (state: ChatClientState) => void): void;
}

// @public
export type StatefulChatClientArgs = {
    userId: CommunicationUserIdentifier;
    displayName: string;
    endpoint: string;
    credential: CommunicationTokenCredential;
};

// @public
export type StatefulChatClientOptions = {
    chatClientOptions: ChatClientOptions;
    maxStateChangeListeners?: number;
};

// @public
export interface StatefulDeviceManager extends DeviceManager {
    selectCamera: (VideoDeviceInfo: any) => void;
}

// @public
export const StreamMedia: (props: StreamMediaProps) => JSX.Element;

// @public
export interface StreamMediaProps {
    isMirrored?: boolean;
    loadingState?: LoadingState;
    styles?: BaseCustomStyles;
    videoStreamElement: HTMLElement | null;
}

// @public
export type SystemMessage = ParticipantAddedSystemMessage | ParticipantRemovedSystemMessage | TopicUpdatedSystemMessage | ContentSystemMessage;

// @public
export interface SystemMessageCommon extends MessageCommon {
    // (undocumented)
    iconName: string;
    // (undocumented)
    messageType: 'system';
}

// @beta
export interface TeamsCallingHandlers extends CommonCallingHandlers {
    // (undocumented)
    onStartCall: (participants: CommunicationIdentifier[], options?: StartCallOptions) => undefined | /* @conditional-compile-remove(teams-identity-support) */ TeamsCall;
}

// @public
export const toFlatCommunicationIdentifier: (identifier: CommunicationIdentifier) => string;

// @public
export type TopicChangedListener = (event: {
    topic: string;
}) => void;

// @public
export interface TopicUpdatedSystemMessage extends SystemMessageCommon {
    // (undocumented)
    systemMessageType: 'topicUpdated';
    // (undocumented)
    topic: string;
}

// @public
export interface TranscriptionCallFeature {
    isTranscriptionActive: boolean;
}

// @public
export const TypingIndicator: (props: TypingIndicatorProps) => JSX.Element;

// @public
export interface TypingIndicatorProps {
    onRenderUser?: (users: CommunicationParticipant) => JSX.Element;
    strings?: Partial<TypingIndicatorStrings>;
    styles?: TypingIndicatorStylesProps;
    typingUsers: CommunicationParticipant[];
}

// @public
export type TypingIndicatorSelector = (state: ChatClientState, props: ChatBaseSelectorProps) => {
    typingUsers: CommunicationParticipant[];
};

// @public
export interface TypingIndicatorStrings {
    delimiter: string;
    multipleUsers: string;
    multipleUsersAbbreviateMany: string;
    multipleUsersAbbreviateOne: string;
    singleUser: string;
}

// @public
export interface TypingIndicatorStylesProps extends BaseCustomStyles {
    typingString?: IStyle;
    typingUserDisplayName?: IStyle;
}

// @beta
export const UnsupportedBrowser: (props: UnsupportedBrowserProps) => JSX.Element;

// @beta
export interface UnsupportedBrowserProps {
    onTroubleshootingClick?: () => void;
    strings: UnsupportedBrowserStrings;
}

// @beta
export interface UnsupportedBrowserStrings {
    moreHelpLink: string;
    primaryText: string;
    secondaryText: string;
}

// @public
export type UpdateMessageCallback = (messageId: string, content: string, metadata?: Record<string, string>, options?: {
    attachedFilesMetadata?: FileMetadata[];
}) => Promise<void>;

// @public
export const useAzureCommunicationCallAdapter: (args: Partial<AzureCommunicationCallAdapterArgs>, afterCreate?: ((adapter: CallAdapter) => Promise<CallAdapter>) | undefined, beforeDispose?: ((adapter: CallAdapter) => Promise<void>) | undefined) => CallAdapter | undefined;

// @public
export const useAzureCommunicationCallWithChatAdapter: (args: Partial<AzureCommunicationCallWithChatAdapterArgs>, afterCreate?: ((adapter: CallWithChatAdapter) => Promise<CallWithChatAdapter>) | undefined, beforeDispose?: ((adapter: CallWithChatAdapter) => Promise<void>) | undefined) => CallWithChatAdapter | undefined;

// @public
export const useAzureCommunicationChatAdapter: (args: Partial<AzureCommunicationChatAdapterArgs>, afterCreate?: ((adapter: ChatAdapter) => Promise<ChatAdapter>) | undefined, beforeDispose?: ((adapter: ChatAdapter) => Promise<void>) | undefined) => ChatAdapter | undefined;

// @public
export const useCall: () => Call | undefined;

// @public
export const useCallAgent: () => CallAgent | undefined;

// @public
export const useCallClient: () => StatefulCallClient;

// @public
export const useChatClient: () => StatefulChatClient;

// @public
export const useChatThreadClient: () => ChatThreadClient;

// @public
export const useDeviceManager: () => StatefulDeviceManager | undefined;

// @public
export const usePropsFor: <Component extends (props: any) => JSX.Element>(component: Component, type?: "chat" | "calling" | undefined) => ComponentProps<Component>;

// @public
export const useSelector: <ParamT extends Selector | undefined>(selector: ParamT, selectorProps?: (ParamT extends Selector ? Parameters<ParamT>[1] : undefined) | undefined, type?: "chat" | "calling" | undefined) => ParamT extends Selector ? ReturnType<ParamT> : undefined;

// @beta
export const useTeamsCall: () => undefined | /* @conditional-compile-remove(teams-identity-support) */ TeamsCall;

// @beta
export const useTeamsCallAgent: () => undefined | /* @conditional-compile-remove(teams-identity-support) */ TeamsCallAgent;

// @public
export const useTheme: () => Theme;

// @public
export const VideoGallery: (props: VideoGalleryProps) => JSX.Element;

// @public (undocumented)
export type VideoGalleryLayout = 'default' | 'floatingLocalVideo';

// @public
export type VideoGalleryLocalParticipant = VideoGalleryParticipant;

// @public
export type VideoGalleryParticipant = {
    userId: string;
    isMuted?: boolean;
    displayName?: string;
    videoStream?: VideoGalleryStream;
    isScreenSharingOn?: boolean;
};

// @public
export interface VideoGalleryProps {
    dominantSpeakers?: string[];
    layout?: VideoGalleryLayout;
    localParticipant: VideoGalleryLocalParticipant;
    localVideoCameraCycleButtonProps?: LocalVideoCameraCycleButtonProps;
    localVideoViewOptions?: VideoStreamOptions;
    maxRemoteVideoStreams?: number;
    onCreateLocalStreamView?: (options?: VideoStreamOptions) => Promise<void | CreateVideoStreamViewResult>;
    onCreateRemoteStreamView?: (userId: string, options?: VideoStreamOptions) => Promise<void | CreateVideoStreamViewResult>;
    onDisposeLocalStreamView?: () => void;
    onDisposeRemoteStreamView?: (userId: string) => Promise<void>;
    onRenderAvatar?: OnRenderAvatarCallback;
    onRenderLocalVideoTile?: (localParticipant: VideoGalleryLocalParticipant) => JSX.Element;
    onRenderRemoteVideoTile?: (remoteParticipant: VideoGalleryRemoteParticipant) => JSX.Element;
    remoteParticipants?: VideoGalleryRemoteParticipant[];
    remoteVideoViewOptions?: VideoStreamOptions;
    showCameraSwitcherInLocalPreview?: boolean;
    showMuteIndicator?: boolean;
    strings?: Partial<VideoGalleryStrings>;
    styles?: VideoGalleryStyles;
}

// @public
export interface VideoGalleryRemoteParticipant extends VideoGalleryParticipant {
    isSpeaking?: boolean;
    screenShareStream?: VideoGalleryStream;
    // @beta
    state?: ParticipantState;
}

// @public
export type VideoGallerySelector = (state: CallClientState, props: CallingBaseSelectorProps) => {
    screenShareParticipant: VideoGalleryRemoteParticipant | undefined;
    localParticipant: VideoGalleryLocalParticipant;
    remoteParticipants: VideoGalleryRemoteParticipant[];
    dominantSpeakers?: string[];
};

// @public
export interface VideoGalleryStream {
    id?: number;
    isAvailable?: boolean;
    isMirrored?: boolean;
    isReceiving?: boolean;
    renderElement?: HTMLElement;
}

// @public
export interface VideoGalleryStrings {
    displayNamePlaceholder: string;
    localVideoCameraSwitcherLabel: string;
    localVideoLabel: string;
    localVideoMovementLabel: string;
    localVideoSelectedDescription: string;
    screenIsBeingSharedMessage: string;
    screenShareLoadingMessage: string;
}

// @public
export interface VideoGalleryStyles extends BaseCustomStyles {
    gridLayout?: GridLayoutStyles;
    horizontalGallery?: HorizontalGalleryStyles;
    localVideo?: IStyle;
}

// @public
export interface VideoStreamOptions {
    isMirrored?: boolean;
    scalingMode?: ViewScalingMode;
}

// @public
export interface VideoStreamRendererViewState {
    isMirrored: boolean;
    scalingMode: ScalingMode;
    target: HTMLElement;
}

// @public
export const VideoTile: (props: VideoTileProps) => JSX.Element;

// @beta
export type VideoTileMenuItems = Array<{
    key: string;
    ariaLabel?: string;
    text: string;
    onClick: () => void;
    iconProps: IIconProps;
}>;

// @public
export interface VideoTileProps {
    children?: React_2.ReactNode;
    displayName?: string;
    initialsName?: string;
    isMirrored?: boolean;
    isMuted?: boolean;
    isPinned?: boolean;
    isSpeaking?: boolean;
    menuItems?: VideoTileMenuItems;
    noVideoAvailableAriaLabel?: string;
    onRenderPlaceholder?: OnRenderAvatarCallback;
    participantState?: ParticipantState;
    personaMaxSize?: number;
    personaMinSize?: number;
    renderElement?: JSX.Element | null;
    showLabel?: boolean;
    showMuteIndicator?: boolean;
    // (undocumented)
    strings?: VideoTileStrings;
    styles?: VideoTileStylesProps;
    userId?: string;
}

// @beta
export interface VideoTileStrings {
    // (undocumented)
    participantStateConnecting: string;
    // (undocumented)
    participantStateHold: string;
    // (undocumented)
    participantStateRinging: string;
}

// @public
export interface VideoTileStylesProps extends BaseCustomStyles {
    displayNameContainer?: IStyle;
    overlayContainer?: IStyle;
    videoContainer?: IStyle;
}

// @public
export type ViewScalingMode = 'Stretch' | 'Crop' | 'Fit';

```