import { ConversationTranslatorRecognizer, IInternalConversation } from "../../common.speech/Exports";
import { IDisposable } from "../../common/Exports";
import { ConversationTranslator, Participant, PropertyCollection, SpeechTranslationConfig } from "../Exports";
import { Callback, IConversation } from "./IConversation";
import { IParticipant, IUser } from "./IParticipant";
export declare abstract class Conversation implements IConversation {
    abstract get authorizationToken(): string;
    abstract set authorizationToken(value: string);
    abstract get config(): SpeechTranslationConfig;
    abstract get conversationId(): string;
    abstract get properties(): PropertyCollection;
    abstract get speechRecognitionLanguage(): string;
    protected constructor();
    /**
     * Create a conversation
     * @param speechConfig
     * @param cb
     * @param err
     */
    static createConversationAsync(speechConfig: SpeechTranslationConfig, cb?: Callback, err?: Callback): Conversation;
    /** Start a conversation. */
    abstract startConversationAsync(cb?: Callback, err?: Callback): void;
    /** Delete a conversation. After this no one will be able to join the conversation. */
    abstract deleteConversationAsync(cb?: Callback, err?: Callback): void;
    /** End a conversation. */
    abstract endConversationAsync(cb?: Callback, err?: Callback): void;
    /** Lock a conversation. This will prevent new participants from joining. */
    abstract lockConversationAsync(cb?: Callback, err?: Callback): void;
    /**
     * Mute all other participants in the conversation. After this no other participants will
     * have their speech recognitions broadcast, nor be able to send text messages.
     */
    abstract muteAllParticipantsAsync(cb?: Callback, err?: Callback): void;
    /**
     * Mute a participant.
     * @param userId A user identifier
     */
    abstract muteParticipantAsync(userId: string, cb?: Callback, err?: Callback): void;
    /**
     * Remove a participant from a conversation using the user id, Participant or User object
     * @param userId A user identifier
     */
    abstract removeParticipantAsync(userId: string | IParticipant | IUser, cb?: Callback, err?: Callback): void;
    /** Unlocks a conversation. */
    abstract unlockConversationAsync(cb?: Callback, err?: Callback): void;
    /** Unmute all other participants in the conversation. */
    abstract unmuteAllParticipantsAsync(cb?: Callback, err?: Callback): void;
    /**
     * Unmute a participant.
     * @param userId A user identifier
     */
    abstract unmuteParticipantAsync(userId: string, cb?: Callback, err?: Callback): void;
}
export declare class ConversationImpl extends Conversation implements IDisposable {
    private privConfig;
    private privProperties;
    private privLanguage;
    private privToken;
    private privIsDisposed;
    private privRoom;
    private privManager;
    private privConversationRecognizer;
    private privConversationRecognizerConnection;
    private privIsConnected;
    private privParticipants;
    private privIsReady;
    private privConversationTranslator;
    private privErrors;
    private readonly privTextMessageMaxLength;
    set conversationTranslator(value: ConversationTranslator);
    get room(): IInternalConversation;
    get connection(): ConversationTranslatorRecognizer;
    get authorizationToken(): string;
    set authorizationToken(value: string);
    get config(): SpeechTranslationConfig;
    get conversationId(): string;
    get properties(): PropertyCollection;
    get speechRecognitionLanguage(): string;
    get isMutedByHost(): boolean;
    get isConnected(): boolean;
    get participants(): Participant[];
    get me(): Participant;
    get host(): Participant;
    /**
     * Create a conversation impl
     * @param speechConfig
     */
    constructor(speechConfig: SpeechTranslationConfig);
    /**
     * Create a new conversation as Host
     * @param cb
     * @param err
     */
    createConversationAsync(cb?: Callback, err?: Callback): void;
    /**
     * Starts a new conversation as host.
     * @param cb
     * @param err
     */
    startConversationAsync(cb?: Callback, err?: Callback): void;
    /**
     * Join a conversation as a participant.
     * @param conversation
     * @param nickname
     * @param lang
     * @param cb
     * @param err
     */
    joinConversationAsync(conversationId: string, nickname: string, lang: string, cb?: Callback, err?: Callback): void;
    /**
     * Deletes a conversation
     * @param cb
     * @param err
     */
    deleteConversationAsync(cb?: Callback, err?: Callback): void;
    /**
     * Issues a request to close the client websockets
     * @param cb
     * @param err
     */
    endConversationAsync(cb?: Callback, err?: Callback): void;
    /**
     * Issues a request to lock the conversation
     * @param cb
     * @param err
     */
    lockConversationAsync(cb?: Callback, err?: Callback): void;
    /**
     * Issues a request to mute the conversation
     * @param cb
     * @param err
     */
    muteAllParticipantsAsync(cb?: Callback, err?: Callback): void;
    /**
     * Issues a request to mute a participant in the conversation
     * @param userId
     * @param cb
     * @param err
     */
    muteParticipantAsync(userId: string, cb?: Callback, err?: Callback): void;
    /**
     * Issues a request to remove a participant from the conversation
     * @param userId
     * @param cb
     * @param err
     */
    removeParticipantAsync(userId: string | IParticipant | IUser, cb?: Callback, err?: Callback): void;
    /**
     * Issues a request to unlock the conversation
     * @param cb
     * @param err
     */
    unlockConversationAsync(cb?: Callback, err?: Callback): void;
    /**
     * Issues a request to unmute all participants in the conversation
     * @param cb
     * @param err
     */
    unmuteAllParticipantsAsync(cb?: Callback, err?: Callback): void;
    /**
     * Issues a request to unmute a participant in the conversation
     * @param userId
     * @param cb
     * @param err
     */
    unmuteParticipantAsync(userId: string, cb?: Callback, err?: Callback): void;
    /**
     * Send a text message
     * @param message
     * @param cb
     * @param err
     */
    sendTextMessageAsync(message: string, cb?: Callback, err?: Callback): void;
    /**
     * Change nickname
     * @param message
     * @param cb
     * @param err
     */
    changeNicknameAsync(nickname: string, cb?: Callback, err?: Callback): void;
    isDisposed(): boolean;
    dispose(reason?: string): void;
    /** websocket callbacks */
    private onConnected;
    private onDisconnected;
    private onCanceled;
    private onParticipantUpdateCommandReceived;
    private onLockRoomCommandReceived;
    private onMuteAllCommandReceived;
    private onParticipantJoinCommandReceived;
    private onParticipantLeaveCommandReceived;
    private onTranslationReceived;
    private onParticipantsListReceived;
    private onConversationExpiration;
    private close;
    /** Helpers */
    private get canSend();
    private get canSendAsHost();
    private handleCallback;
    private handleError;
    /** Participant Helpers */
    private toParticipants;
    private toParticipant;
}