import { BaseStateMachine } from '../../tools/BaseStateMachine';
import { EEvents, EState } from './constants';
import { TCallEvents } from '../../CallManager';
import { TEvents as TPresentationEvents } from '../events';
import { TContext, TContextMap, TPresentationMachineEvents } from './types';
declare const presentationMachine: import('xstate').StateMachine<{
    lastError: Error | undefined;
    videoTrack: MediaStreamVideoTrack | undefined;
}, {
    type: EEvents.SCREEN_STARTING;
    videoTrack?: MediaStreamVideoTrack;
} | {
    type: EEvents.SCREEN_STARTED;
    videoTrack?: MediaStreamVideoTrack;
} | {
    type: EEvents.SCREEN_UPDATING;
    videoTrack: MediaStreamVideoTrack;
} | {
    type: EEvents.SCREEN_UPDATED;
    videoTrack: MediaStreamVideoTrack;
} | {
    type: EEvents.SCREEN_ENDING;
} | {
    type: EEvents.SCREEN_ENDED;
} | {
    type: EEvents.SCREEN_FAILED;
    error?: unknown;
} | {
    type: EEvents.CALL_ENDED;
} | {
    type: EEvents.CALL_FAILED;
    error?: unknown;
} | {
    type: EEvents.PRESENTATION_RESET;
}, {}, never, {
    type: import("./constants").EAction.LOG_TRANSITION;
    params: {
        from: string;
        to: string;
        event: string;
    };
} | {
    type: import("./constants").EAction.LOG_STATE_CHANGE;
    params: {
        state: string;
    };
} | {
    type: import("./constants").EAction.SET_ERROR;
    params: import('xstate').NonReducibleUnknown;
} | {
    type: import("./constants").EAction.CLEAR_ERROR;
    params: import('xstate').NonReducibleUnknown;
} | {
    type: import("./constants").EAction.SET_VIDEO_TRACK;
    params: import('xstate').NonReducibleUnknown;
} | {
    type: import("./constants").EAction.CLEAR_VIDEO_TRACK;
    params: import('xstate').NonReducibleUnknown;
}, never, never, EState, string, import('xstate').NonReducibleUnknown, import('xstate').NonReducibleUnknown, import('xstate').EventObject, import('xstate').MetaObject, {
    id: "presentation";
    states: {
        readonly idle: {};
        readonly starting: {};
        readonly active: {};
        readonly stopping: {};
        readonly failed: {};
    };
}>;
export type TSnapshot = {
    value: EState.IDLE;
    context: TContextMap[EState.IDLE];
} | {
    value: EState.STARTING;
    context: TContextMap[EState.STARTING];
} | {
    value: EState.ACTIVE;
    context: TContextMap[EState.ACTIVE];
} | {
    value: EState.STOPPING;
    context: TContextMap[EState.STOPPING];
} | {
    value: EState.FAILED;
    context: TContextMap[EState.FAILED];
};
export declare class PresentationStateMachine extends BaseStateMachine<typeof presentationMachine, EState, TContext, TSnapshot> {
    constructor(presentationEvents: TPresentationEvents, callEvents: TCallEvents);
    get isIdle(): boolean;
    get isStarting(): boolean;
    get isActive(): boolean;
    get isStopping(): boolean;
    get isFailed(): boolean;
    get isPending(): boolean;
    get isActiveOrPending(): boolean;
    get lastError(): Error | undefined;
    get activeVideoTrack(): MediaStreamVideoTrack | undefined;
    get pendingVideoTrack(): MediaStreamVideoTrack | undefined;
    reset(): void;
    send(event: TPresentationMachineEvents): void;
    private hasState;
    private sendEvent;
    private subscribePresentationEvents;
    private subscribeCallEvents;
}
export {};