import { BaseStateMachine } from '../../tools/BaseStateMachine';
import { EEvents, EState } from './constants';
import { TEvents as TConnectionEvents } from '../../ConnectionManager/events';
import { TEvents as TIncomingEvents, TRemoteCallerData } from '../events';
import { TContextMap, TFinishedReason, TIncomingMachineEvents, TContext } from './types';
declare const incomingMachine: import('xstate').StateMachine<{
    remoteCallerData: undefined;
    lastReason: undefined;
} | {
    remoteCallerData: TRemoteCallerData;
    lastReason: undefined;
} | {
    remoteCallerData: TRemoteCallerData;
    lastReason: EState.CONSUMED;
} | {
    remoteCallerData: TRemoteCallerData;
    lastReason: EState.DECLINED;
} | {
    remoteCallerData: TRemoteCallerData;
    lastReason: EState.TERMINATED;
} | {
    remoteCallerData: TRemoteCallerData;
    lastReason: EState.FAILED;
}, {
    type: EEvents.RINGING;
    data: TRemoteCallerData;
} | {
    type: EEvents.CONSUMED;
} | {
    type: EEvents.DECLINED;
    data: TRemoteCallerData;
} | {
    type: EEvents.TERMINATED;
    data: TRemoteCallerData;
} | {
    type: EEvents.FAILED;
    data: TRemoteCallerData;
} | {
    type: EEvents.CLEAR;
}, {}, 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.REMEMBER_INCOMING;
    params: import('xstate').NonReducibleUnknown;
} | {
    type: import("./constants").EAction.REMEMBER_REASON;
    params: import('xstate').NonReducibleUnknown;
} | {
    type: import("./constants").EAction.CLEAR_INCOMING;
    params: import('xstate').NonReducibleUnknown;
}, never, never, EState, string, import('xstate').NonReducibleUnknown, import('xstate').NonReducibleUnknown, import('xstate').EventObject, import('xstate').MetaObject, {
    id: "incoming";
    states: {
        readonly "incoming:idle": {};
        readonly "incoming:ringing": {};
        readonly "incoming:consumed": {};
        readonly "incoming:declined": {};
        readonly "incoming:terminated": {};
        readonly "incoming:failed": {};
    };
}>;
export type TSnapshot = {
    value: EState.IDLE;
    context: TContextMap[EState.IDLE];
} | {
    value: EState.RINGING;
    context: TContextMap[EState.RINGING];
} | {
    value: EState.CONSUMED;
    context: TContextMap[EState.CONSUMED];
} | {
    value: EState.DECLINED;
    context: TContextMap[EState.DECLINED];
} | {
    value: EState.TERMINATED;
    context: TContextMap[EState.TERMINATED];
} | {
    value: EState.FAILED;
    context: TContextMap[EState.FAILED];
};
type TDeps = {
    incomingEvents: TIncomingEvents;
    connectionEvents: TConnectionEvents;
};
export declare class IncomingCallStateMachine extends BaseStateMachine<typeof incomingMachine, EState, TContext, TSnapshot> {
    constructor({ incomingEvents, connectionEvents }: TDeps);
    get isIdle(): boolean;
    get isRinging(): boolean;
    get isConsumed(): boolean;
    get isDeclined(): boolean;
    get isTerminated(): boolean;
    get isFailed(): boolean;
    get isActive(): boolean;
    get isFinished(): boolean;
    get remoteCallerData(): TRemoteCallerData | undefined;
    get lastReason(): TFinishedReason | undefined;
    readonly toConsumed: () => void;
    reset(): void;
    send(event: TIncomingMachineEvents): void;
    private hasState;
    private sendEvent;
    private subscribeIncomingEvents;
    private subscribeConnectionEvents;
    private readonly toClearIncoming;
}
export {};