/**
 * @module BubbleConferenceRecap
 */
import { FileDescriptor } from '../models/common/fileDescriptor';
import { FileDocument } from './fileDocument.model';
import { RBEvent } from './event.model';
import { Subscription } from 'rxjs';
import { User } from './user.model';
import { Bubble } from './bubble.model';
export declare class BubbleConferenceRecapTranscriptMessage {
    id: string;
    start: number;
    end: number;
    text: string;
    speaker?: User;
    isActive: boolean;
    searched: boolean;
    static create(start: number, end: number, text: string, speaker: User): BubbleConferenceRecapTranscriptMessage;
}
export interface RecapViewer {
    type: "bubble" | "user";
    user?: User;
    bubble?: Bubble;
}
export type BubbleConferenceRecapDocumentTypes = 'poster' | 'chat' | 'audio' | 'video' | 'summary' | 'transcriptionText' | 'transcriptionJson' | 'subtitles' | 'chapters';
export interface BubbleConferenceRecap {
    /**
     * Unique identifier for the conference recap.
     */
    id?: string;
    /**
     * Start date of the recap in ISO format.
     */
    startDate?: string;
    /**
     * Stop date of the recap in ISO format.
     */
    stopDate?: string;
    /**
     * List of records associated with the conference recap.
     * @internal
     */
    records?: BubbleConferenceRecapFile[];
    /**
     * Identifier of the bubble (conference) associated with the recap.
     */
    bubbleId?: string;
    /**
     * Name of the bubble (conference) associated with the recap.
     */
    bubbleName?: string;
    /**
     * Topic of the bubble (conference) associated with the recap.
     */
    bubbleTopic?: string;
    /**
     * Status of the conference recap (RecapStatusEnum).
     */
    status: RecapStatusEnum;
    /**
     * Identifier of the user who created the recap.
     */
    userId?: string;
    /**
     * URL of the bubble's avatar.
     */
    avatarURL?: string;
    /**
     * TRUE If summary is asked for this recording
     */
    summaryAsked?: boolean;
    /**
     * Status of the summary (e.g., 'none', 'failed', 'release_complete', 'in-progress').
     * NB !!! summaryStatus is basically the same as the transcriptionStatus (it's actually the same status for both);
     */
    summaryStatus?: RecapStatusEnum;
    /**
     * TRUE If transcription is asked for this recording
     */
    transcriptionAsked?: boolean;
    /**
     * Status of the transcription (e.g., 'none', 'failed', 'release_complete', 'in-progress').
     */
    transcriptionStatus?: RecapStatusEnum;
    /**
     * In case of error during the transcription, here we can find the details of the error;
     * Information sent by the backed is as follows:
        const TRANSCRIPTION_REASON = {
        NONE: 'none',
        API_KEY_ERROR: 'apikey_error',
        RATE_LIMIT_EXCEEDED: 'rate_limit_exceeded',
        INSUFFICIENT_CREDITS: 'insufficient_credits',
        FORBIDDEN_ACCESS: 'forbidden_access',
        SERVER_ERROR: 'server_error',
        INVALID_DATA: 'invalid_data',
        INTERNAL_ERROR: 'internal_error',
        };
     */
    transcriptionErrorReason: RecapErrorReasonEnum;
    /**
     * Status of the meeting recording (e.g., 'release_complete', 'in-progress').
     */
    recordingStatus?: RecapStatusEnum;
    /**
     * Define auto expiry of the recording
     * false : A meeting record and eventually its transcription and its summary are always available until the recording is deleted.
     * true : That is to say only the transcription and the summary will remain. The date timeToLiveDate is taken in account to schedule a cleaning task.
     */
    isEphemeral?: boolean;
    /**
     * Property related to the  auto expiry of the recording
     * false : The meeeting recording is available;
     * true : The meeting recording has expired and is no longer available. The transcription and summary can still be seen (if available)
     */
    isCleaned?: boolean;
    /**
     * Date (as string) from which a cleaning task might be scheduled. Linked to isEphemeral property
     */
    timeToLiveDate: string;
    /**
     * List of actions currently possible for this recap
     */
    actions: BubbleConferenceRecapActions;
    /**
     * Delete conference recap
     */
    delete(): Promise<void>;
    /**
     * Get recap document by type
     * @param type - the document type to retreive
     */
    getFileDocument(type: BubbleConferenceRecapDocumentTypes): Promise<FileDocument | undefined>;
    getTranscriptMessages(): Promise<BubbleConferenceRecapTranscriptMessage[]>;
    getSpeakerRanges(): any[];
    getSummary(): Promise<string | undefined>;
    getSubtitlesUrl(): Promise<string | undefined>;
    getVideoUrl(): Promise<string | undefined>;
    getBubble(): Promise<Bubble>;
    getDuration(): number;
    getPublisher(): Promise<User>;
    getParticipants(): Promise<User[]>;
    /**
     * Permit to control if a recap has a doument of type 'type' or not
     * @param type - the document type to control
     */
    hasDocumentOfType(type: BubbleConferenceRecapDocumentTypes): boolean;
    /**
     * Debug Method to return a simplified JSON representation of the User object.
     * @internal
     */
    toJSON(): any;
    getRecapStatus(): BubbleConferenceRecapStatus;
    subscribe(handler: (event: RBEvent<BubbleConferenceRecapEvents>) => any, eventNames?: BubbleConferenceRecapEvents | BubbleConferenceRecapEvents[]): Subscription;
    /** @internal */
    associatedRecordingFiles?: FileDescriptor[];
    /** @internal */
    overallArchiveSize?: number;
    /** @internal */
    updateFromData(data: any): void;
    /** @internal */
    isSharedWith(destination: User | Bubble): boolean;
    /** @internal */
    dashFilesAvailable: boolean;
    /** @internal */
    downloadInProgress: boolean;
    /** @internal */
    viewers: any[];
    /**
     * Disable the auto delete for the recording video;
     * Related to property "isEphemeral"
     */
    disableEphemeral(): Promise<void>;
    /**
     * This API will create an archive (zip) will all files available in the recap; Once generated, the zip will be available in the user storage;
     * ATTENTION: In return you'll get the FileDocument that can be used to download the archive, but it will remain in the user storage; So consider removing it from the storage in order to save space;
     * Each call of this API will generate a new archive with !
     * @param archiveName - the name of the archive [Optional]
     */
    download(archiveName?: string): Promise<Document>;
    /**
     * Share recap with other users / bubbles
     * The list of user/bubbles that can see this recap can be found via the sharedWith() API
     */
    share(destination: User | Bubble): Promise<void>;
    /**
     * Unshare the recap with the given user / bubble
     */
    unshare(recapViewer: RecapViewer): Promise<void>;
    /**
     * Replace the summary content by the edited one.
     * @param newSummary - String representing the new summary.
     */
    replaceSummaryFile(newSummary: string): Promise<void>;
    /**
     * Get the current list of Users and Bubbles that the recap is being shared with
     */
    sharedWith(): RecapViewer[];
    /**
     * If this recap is mine or belongs to someone else (shared with me)
     */
    isMyRecap(): boolean;
}
export declare enum RecapErrorReasonEnum {
    NONE = "none",
    API_KEY_ERROR = "apikey_error",
    RATE_LIMIT_EXCEEDED = "rate_limit_exceeded",
    INSUFFICIENT_CREDITS = "insufficient_credits",
    FORBIDDEN_ACCESS = "forbidden_access",
    SERVER_ERROR = "server_error",
    INVALID_DATA = "invalid_data",
    INTERNAL_ERROR = "internal_error"
}
export interface BubbleConferenceRecapStatus {
    /**
     * The general status of the recording/recap
     */
    generalRecapStatus: RecapStatusEnum;
    /**
     * The status of the transcription
     */
    transcriptionStatus: RecapStatusEnum;
    /**
     * The status of the summary
     */
    summaryStatus: RecapStatusEnum;
    /**
     * In case of error, details about the error (if any)
     */
    errorReason: RecapErrorReasonEnum;
}
export declare enum RecapStatusEnum {
    /**
     * The operation has finished without error
     */
    READY = "release_complete",
    /**
     * The opration has failed
     */
    FAILED = "failed",
    /**
     * The opration is in progress (some files are available)
     */
    IN_PROGRESS = "in_progress",
    /**
     * The opration is initiated (no files are available yet)
     */
    INITIATED = "initiated",
    /**
     * The opration is not asked
     */
    NONE = "none"
}
/**
 * BubbleConference public events
 * @eventProperty
 */
export declare enum BubbleConferenceRecapEvents {
    /**
    * @eventProperty
    * This RBEvent is fired when the bubbleConferenceRecap status is updated
    */
    ON_STATUS_CHANGE = "ON_STATUS_CHANGE",
    /**
    * @eventProperty
    * This RBEvent is fired when the isEphemeral property is updated
    */
    ON_EPHEMERAL_CHANGE = "ON_EPHEMERAL_CHANGE",
    /**
    * @eventProperty
    * This RBEvent is fired when the recap actions property are updated
    */
    ON_RECAP_ACTIONS_CHANGE = "ON_RECAP_ACTIONS_CHANGE",
    /**
    * @eventProperty
    * This RBEvent is fired when the list of viewers have changed
    */
    ON_RECAP_VIEWERS_CHANGE = "ON_RECAP_VIEWERS_CHANGE"
}
export interface BubbleConferenceRecapActions {
    /**
     * Indicates if the recap can be download.
     * @readonly
     */
    download: boolean;
    /**
     * Indicates if the recap can be shared (or unshared) with other users/bubbles (owner only).
     * @readonly
     */
    share: boolean;
    /**
     * Indicates if the recap can be deleted (owner only).
     * @readonly
     */
    delete: boolean;
    /**
     * Indicates if the recap can be played.
     * @readonly
     */
    play: boolean;
    /**
     * Indicates if the recap summary can be modified (owner only).
     * @readonly
     */
    modifySummary: boolean;
    /**
     * Indicates if the recap transcript can be downloaded as text file.
     * @readonly
     */
    downloadTranscript: boolean;
    /**
     * Indicates if the recap auto delete option can be canceled (owner only).
     * @readonly
     */
    disableEphemeral: boolean;
}
/**
 * @internal
 */
export declare class BubbleConferenceRecapRB implements BubbleConferenceRecap {
    id?: string;
    startDate?: string;
    stopDate?: string;
    records?: BubbleConferenceRecapFile[];
    bubbleId?: string;
    bubbleName?: string;
    bubbleTopic?: string;
    status: RecapStatusEnum;
    userId?: string;
    avatarURL?: string;
    associatedRecordingFiles?: FileDescriptor[];
    overallArchiveSize?: number;
    capabilities: BubbleConferenceRecapDocumentTypes[];
    summaryAsked: boolean;
    summaryStatus: RecapStatusEnum;
    transcriptionAsked: boolean;
    transcriptionStatus: RecapStatusEnum;
    transcriptionErrorReason: RecapErrorReasonEnum;
    recordingStatus: RecapStatusEnum;
    isCleaned: boolean;
    participantIds: any[];
    private _isEphemeral;
    private publisher?;
    private bubble?;
    private participants?;
    downloadInProgress: boolean;
    private participantListComplete;
    isMyRecap(): boolean;
    sharedWith(): RecapViewer[];
    private updateViewers;
    private _viewers;
    private _viewersList;
    get viewers(): any[];
    private set viewers(value);
    private _actions;
    get actions(): BubbleConferenceRecapActions;
    private set actions(value);
    get isEphemeral(): boolean;
    set isEphemeral(value: boolean);
    timeToLiveDate: string;
    dashFilesAvailable: boolean;
    private mainService;
    private fileStorageService?;
    private confRecapService?;
    private documentService?;
    private contactService?;
    private bubbleService;
    private loggerService;
    private speakerRanges;
    private visualSpeakerRanges;
    private eventSubject;
    private constructor();
    static createFromData(data: any): BubbleConferenceRecap;
    subscribe(handler: (event: RBEvent<BubbleConferenceRecapEvents>) => any, eventNames?: BubbleConferenceRecapEvents | BubbleConferenceRecapEvents[]): Subscription;
    private sendEvent;
    updateFromData(data: any): void;
    private updateActions;
    share(destination: User | Bubble): Promise<void>;
    unshare(recapViewer: RecapViewer): Promise<void>;
    delete(): Promise<void>;
    download(archiveName?: string): Promise<Document>;
    getFileDocument(type: BubbleConferenceRecapDocumentTypes): Promise<FileDocument | undefined>;
    disableEphemeral(): Promise<void>;
    hasDocumentOfType(type: BubbleConferenceRecapDocumentTypes): boolean;
    isSharedWith(destination: User | Bubble): boolean;
    private updateFromServer;
    getParticipants(): Promise<User[]>;
    getTranscriptMessages(): Promise<BubbleConferenceRecapTranscriptMessage[]>;
    getSpeakerRanges(): any[];
    getSummary(): Promise<string | undefined>;
    getSubtitlesUrl(): Promise<string | undefined>;
    getVideoUrl(): Promise<string | undefined>;
    getBubble(): Promise<Bubble>;
    getPublisher(): Promise<User>;
    /**
     * API used to build a more user friendly information on the current situation with the recap
     */
    getRecapStatus(): BubbleConferenceRecapStatus;
    getDuration(): number;
    toJSON(): any;
    replaceSummaryFile(newSummary: string): Promise<void>;
}
/** @internal */
export declare class BubbleConferenceRecapFile {
    fileId?: string;
    fileName?: string;
    md5sum?: string;
    size?: number;
    typeMIME?: string;
    /** @internal */
    static createFromData(data: any): BubbleConferenceRecapFile;
    private constructor();
}
//# sourceMappingURL=bubbleConferenceRecap.model.d.ts.map