sinch-rtc/npm/src/session/Session.d.ts

RTC JavaScript/Web SDK

import { Message } from "../mxp";
import { Client, SymmetricKey } from "../mxp/models";
import { FsmState, FsmTransition, FsmTransitions, TimerEvent } from "./fsm";
import { JsepMessage, SessionDescription } from "./jsep";
import { TerminationCause } from "./TerminationCause";
import { SessionState } from "./SessionState";
import { Scheduler } from "./Scheduler";
import { SessionEvent } from "../session/SessionEvent";
import { Event } from "../utils/Event";
import { MessageBuilder } from "../mxp/MessageBuilder";
import { Direction } from "./Direction";
import { SinchError } from "../SinchError";
import { MxpClientEvent } from "../mxp/MxpClientEvent";
import { TransitionSource } from "./fsm/TransitionSource";
import { TimerEventType } from "./fsm/TimerEventType";
export type JsepMessageEvent = {
    id: string;
    messages: JsepMessage[];
};
export declare abstract class Session implements FsmTransition {
    protected readonly mxpClient: Client;
    private readonly sessionId;
    private readonly callDirection;
    private readonly scheduler;
    protected constructor(mxpClient: Client, sessionId: string, callDirection: Direction, scheduler: Scheduler);
    get localPeer(): Client;
    get id(): string;
    get direction(): Direction;
    get state(): SessionState;
    get terminationCause(): TerminationCause;
    startedAt?: Date;
    private schedulerCancellations;
    protected fsmState: FsmState;
    protected transitions: FsmTransitions;
    private transitionDepth;
    private pendingJsepMessages;
    private mxpOutboundMessages;
    private pendingInboundMessages;
    private sessionError;
    get error(): SinchError | undefined;
    set error(error: SinchError | undefined);
    private readonly stateChangeEvents;
    private readonly pendingStateChangeEvents;
    private readonly jsepMessageReceivedEvent;
    localDescription?: SessionDescription;
    set onJsepMessageReceived(handler: (evt: JsepMessageEvent) => void);
    protected get outboundMessages(): Message[];
    private symmetricSessionKey;
    hasSessionKey(): boolean;
    onSessionKey: Event<void>;
    get sessionKey(): SymmetricKey | null;
    set sessionKey(key: SymmetricKey | null);
    start(): void;
    private stateChanged;
    set onStateChanged(handler: (e: SessionEvent) => void);
    private outboundMessageEvent;
    set onOutboundMessage(handler: (e: Message) => void);
    newMessage(): MessageBuilder;
    protected setInitialState(state: FsmState): void;
    protected setStartedAt(): void;
    timeoutRelativeToStart(ms: number): number;
    terminate(error?: SinchError): void;
    terminateWithCause(cause: TerminationCause): void;
    onInboundMessage(message: Message): void;
    private applyPendingInboundMessages;
    onTimeout(t: TimerEvent): void;
    onACKWindowTimeout(_: FsmState, __: TimerEvent): void;
    protected tryWithCurrentState(action: (state: FsmState) => void): void;
    sendClientEvent(event: MxpClientEvent): void;
    sendOutboundMessage(message: Message): void;
    hasSentMessage(predicate: (m: Message) => boolean): boolean;
    transition(from: FsmState, to: SessionState, source: TransitionSource): void;
    private emitStateChangeEvents;
    private tryEmitStateChangeEvent;
    private emitStateChangeEvent;
    private applyPendingSessionStateChanges;
    private pushStateChangeEvent;
    private createStateChangeEvent;
    private static createStateChangeEvent;
    emitPendingJsepEvents(): void;
    private emitJsepEvents;
    emitJsepEvent(message: Message): void;
    protected addJsepMessage: (messages: JsepMessage[]) => void;
    addPendingInboundMessage(m: Message): void;
    setLocalCandidate(candidates: JsepMessage[]): void;
    setLocalSessionDescription(message: JsepMessage): void;
    scheduleTimeout(source: FsmState, timeoutMs: number, type: TimerEventType): void;
    private getCancellationToken;
    cancelScheduledTimeouts(source: FsmState): void;
    private onScheduledTimeout;
}