@myinterview/widget-react 1.0.0

package/dist/esm/interfaces/candidateInterface.d.ts

@@ -0,0 +1,10 @@
+export interface ICandidate {
+    candidate_id?: string;
+    email: string;
+    username: string;
+    phone?: string;
+    video_id?: string;
+    redirectUrl?: string;
+    apiKey?: string;
+    company_id?: string;
+}

package/dist/esm/interfaces/candidateSessionInterface.d.ts

@@ -0,0 +1,78 @@
+/**
+ * @author tht7 ( tht7 )
+ * @date 10/07/12022 6:48 pm
+ */
+declare global {
+    interface Window {
+        candidateSession?: ICandidateSession;
+    }
+}
+export declare const enum CandidateSessionError {
+    NO_CANDIDATE_FOUND = "NO_CANDIDATE_FOUND",
+    NO_JOB_FOUND = "NO_JOB_FOUND",
+    DEADLINE_EXPIRED = "DEADLINE_EXPIRED",
+    NO_AUDIO = "NO_AUDIO",
+    NO_VIDEO = "NO_VIDEO",
+    PERMISSIONS_BLOCKED = "PERMISSIONS_BLOCKED",
+    JOB_INACTIVE = "JOB_INACTIVE",
+    SUBSCRIPTION_PAUSED = "SUBSCRIPTION_PAUSED",
+    SUBSCRIPTION_CANCELLED = "SUBSCRIPTION_CANCELLED",
+    INTERVIEW_ALREADY_COMPLETED = "INTERVIEW_ALREADY_COMPLETED"
+}
+export declare const enum CandidateSessionWarnings {
+    LOW_LIGHT = "LOW_LIGHT",
+    LOW_VOLUME = "LOW_VOLUME",
+    SLOW_CONNECTION = "SLOW_CONNECTION"
+}
+export declare type CandidateSessionSourceType = 'direct' | 'email' | 'sms' | 'email_reminder' | 'sms_reminder';
+export declare const enum CandidateSessionSourceMap {
+    direct_start_inter = "direct",
+    reminder_start_inter = "email_reminder",
+    reminder_sms_start_inter = "sms_reminder",
+    email_start_inter = "email",
+    sms_start_inter = "sms"
+}
+export interface ICandidateSession {
+    session_id: string;
+    duration: number;
+    error?: keyof typeof CandidateSessionError;
+    warnings?: (keyof typeof CandidateSessionWarnings)[];
+    reload_count: number;
+    files_uploaded_count: number;
+    company_id: string;
+    apiKey: string;
+    job_id?: string;
+    candidate_id?: string;
+    video_id?: string;
+    email?: string;
+    source?: CandidateSessionSourceType;
+    userAgent?: string;
+    ip?: string;
+    candidate_location?: string;
+    first_interaction?: Date;
+    form_filled?: Date;
+    document_uploaded?: Date;
+    top_tips_shown?: Date;
+    top_tips_clicked?: Date;
+    top_tips_positive_rating?: boolean;
+    widget_shown?: Date;
+    widget_practiced?: Date;
+    widget_camera_setup?: Date;
+    widget_camera_error?: Date;
+    widget_microphone_setup?: Date;
+    widget_microphone_error?: Date;
+    widget_slow_internet_setup?: Date;
+    widget_high_internet_setup?: Date;
+    widget_medium_internet_setup?: Date;
+    widget_no_internet_setup?: Date;
+    widget_start_click_setup?: Date;
+    widget_change_camera_setup?: Date;
+    widget_change_mic_setup?: Date;
+    widget_exit?: Date;
+    widget_retake_count: number;
+    widget_submitted?: Date;
+    widget_completed?: Date;
+    page_closed: Date;
+    createdAt: Date;
+    updatedAt: Date;
+}

package/dist/esm/interfaces/companyInterface.d.ts

@@ -0,0 +1,3 @@
+export interface ICompany {
+    shouldShowWaterMark: boolean;
+}

package/dist/esm/interfaces/configInterface.d.ts

@@ -0,0 +1,33 @@
+import { ICandidate } from './candidateInterface';
+import { ICompany } from './companyInterface';
+import { IJob } from './jobInterface';
+import { IVideo } from './videoInterface';
+export declare type IMessageType = 'completed' | 'deadline' | 'applied' | 'inactiveJob';
+export interface IOnCompleteCallback {
+    redirectUrl?: string;
+    video_id: string;
+}
+export interface IOnError {
+    messageType: IMessageType;
+}
+export interface IConfig {
+    video?: IVideo;
+    candidate: ICandidate;
+    job?: IJob;
+    company?: ICompany;
+    config: {
+        auth: string;
+        onCompleteCallback?: (data: IOnCompleteCallback) => void;
+        onError?: (data: IOnError) => void;
+    };
+}
+export interface IConfigResponse {
+    video: IVideo;
+    candidate: ICandidate;
+    job: IJob;
+}
+export interface IConfigRequest {
+    video?: IVideo;
+    candidate?: ICandidate;
+    job?: IJob;
+}

package/dist/esm/interfaces/jobInterface.d.ts

@@ -0,0 +1,22 @@
+export interface IQuestion {
+    question: string;
+    numOfRetakes: number;
+    partDuration: number;
+    thinkingTime: number;
+    timeLimit?: number;
+    videoQuestion?: string;
+    description?: string;
+}
+export interface IJob {
+    language?: string;
+    overlay?: string;
+    transcriptLanguage?: string;
+    title?: string;
+    company?: string;
+    job_id?: string;
+    logo?: string;
+    questions?: IQuestion[];
+    old_jobID?: string;
+    apiKey?: string;
+    company_id?: string;
+}

package/dist/esm/interfaces/microphoneInterface.d.ts

@@ -0,0 +1,36 @@
+export interface InitialState {
+    mediaStream: MediaStream | null;
+    micData: number;
+    retakes: number;
+}
+export declare const enum STATES {
+    INACTIVE = "inactive",
+    ACTIVE = "active",
+    NOT_RECEIVING_DATA = "notReceivingData",
+    RECEIVING_DATA = "receivingData",
+    DATA_CHECK = "dataCheck"
+}
+export declare const enum ACTIONS {
+    CONSOLE_LOG = "consoleLog",
+    SET_MEDIA_STREAM = "setMediaStream",
+    UPDATE_MIC = "updateMic",
+    UPDATE_RETAKES = "UPDATE_RETAKES",
+    CLEAN_RETAKES = "CLEAN_RETAKES",
+    SENTRY = "sentry"
+}
+export declare const enum EVENTS {
+    ON_SET_MEDIA_STREAM = "ON_SET_MEDIA_STREAM",
+    SEND_DATA = "SEND_DATA",
+    MIC_CHECK = "MIC_CHECK",
+    SEND_ERROR = "SEND_ERROR",
+    UPDATE_RETAKES = "UPDATE_RETAKES",
+    CLEAN_RETAKES = "CLEAN_RETAKES"
+}
+export declare const enum SERVICES {
+    CHECK_MICROPHONE_LEVEL = "checkMicrophoneLevel"
+}
+export declare const enum GUARDS {
+    IS_MEDIA_STREAM_AVAILABLE = "isMediaStreamAvailable",
+    IS_MIC_NOT_RECEIVING_DATA = "isMicNotReceivingData",
+    IS_MIC_RECEIVING_DATA = "isMicReceivingData"
+}

package/dist/esm/interfaces/networkInterface.d.ts

@@ -0,0 +1,9 @@
+export declare const enum STATES {
+    READY = "ready"
+}
+export declare const enum ACTIONS {
+    SET_CONNECTION = "setConnection"
+}
+export declare const enum EVENTS {
+    CONNECTION_CHANGED = "CONNECTION_CHANGED"
+}

package/dist/esm/interfaces/previewInterface.d.ts

@@ -0,0 +1,14 @@
+export interface PreviewInterface {
+    videosUrls: string[];
+}
+export declare const enum STATES {
+    IDLE = "idle",
+    ERROR = "error",
+    FINISH = "finish"
+}
+export declare const enum EVENTS {
+    TAKES_RECEIVED = "TAKES_RECEIVED"
+}
+export declare const enum ACTIONS {
+    SET_TAKES = "setTakes"
+}

package/dist/esm/interfaces/recorderInterface.d.ts

@@ -0,0 +1,110 @@
+import { ActorRef, DoneInvokeEvent } from 'xstate';
+import { RefObject } from 'react';
+export interface RecorderInterface {
+    isDefaultConstraint: boolean;
+    audioDevices?: MediaDeviceInfo[];
+    videoDevices?: MediaDeviceInfo[];
+    selectedAudioDevice?: MediaDeviceInfo;
+    selectedVideoDevice?: MediaDeviceInfo;
+    mediaRecorder?: MediaRecorder | null;
+    mediaStream?: MediaStream | null;
+    videoRef: RefObject<HTMLVideoElement>;
+    microphoneRef: ActorRef<DoneInvokeEvent<any>> | null;
+    speedTestLevel: SPEED_TEST_LEVEL;
+    videoBitsPerSecond: number;
+    mimeType: string;
+    mimeTypes: string[];
+    error: {};
+    countdown: number;
+    recordingTime: number;
+    facingMode: any;
+    durations: number;
+    constraint: ConstrainProps;
+    autoStart: boolean;
+    isMicError: boolean;
+}
+interface ConstrainProps {
+    video: {
+        width: {
+            min?: number;
+            ideal?: number;
+            max: number;
+        };
+        aspectRatio?: number;
+    };
+    audio: boolean;
+}
+export declare type mediaDeviceType = 'video' | 'audio';
+export declare const enum STATES {
+    INIT = "init",
+    IDLE = "idle",
+    RECORDING = "recording",
+    WAITING = "waiting",
+    ERROR = "error"
+}
+export declare const enum RECORDER_STATES {
+    INIT_RECORDER = "initRecorder",
+    COUNT_DOWN = "countDown",
+    COLLECTING_BLOBS = "collectingBlobs",
+    RECORDER_TIMER = "recorderTimer",
+    RECORDER_SENDING_BLOBS = "recorderSendingBlobs"
+}
+export declare const enum RECORDER_EVENTS {
+    PAUSE = "PAUSE",
+    START_RECORDING = "START_RECORDING",
+    STOP_RECORDING = "STOP_RECORDING",
+    RETRY = "RETRY",
+    SET_QUESTION_PARAMS = "SET_QUESTION_PARAMS",
+    CHANGE_VIDEO_DEVICE = "CHANGE_VIDEO_DEVICE",
+    CHANGE_AUDIO_DEVICE = "CHANGE_AUDIO_DEVICE",
+    TICK = "TICK",
+    FORCE_START = "FORCE_START",
+    INIT_RECORDER = "INIT_RECORDER",
+    SAVE = "SAVE",
+    RE_INIT = "RE_INIT",
+    MIC_DATA_RECEIVED = "MIC_DATA_RECEIVED",
+    SPEED_TEST_RESULT_UPDATED = "SPEED_TEST_RESULT_UPDATED"
+}
+export declare const enum ACTIONS {
+    CLEAN_MIC_ERROR = "CLEAN_MIC_ERROR",
+    SET_MIC_ERROR = "setMicError",
+    DISABLE_AUTO_START = "disableAutoStart",
+    AUTO_START = "autoStart",
+    PAUSE_MEDIA_RECORDER = "pauseMediaRecorder",
+    ACTIVATE_MEDIA_RECORDER = "activateMediaRecorder",
+    SESSION_EVENT = "sessionEvent",
+    DISABLE_DEFAULT_CONSTRAINT = "disableDefaultConstraint",
+    SET_DEFAULT_CONSTRAINT = "setDefaultConstraint",
+    SET_MEDIA_STREAM = "setMediaStream",
+    SET_ERROR = "setError",
+    SET_INITIAL_CONTEXT = "setInitialContext",
+    STOP_MEDIA_STREAM = "stopMediaStream",
+    SET_MEDIA_STREAM_AUDIO_CHANGE = "setMediaStreamAudioChange",
+    SET_MEDIA_STREAM_VIDEO_CHANGE = "setMediaStreamVideoChange",
+    SET_MIC_MEDIA_STREAM = "SET_MIC_MEDIA_STREAM",
+    SAVE_TAKE = "SAVE_TAKE",
+    CLEAN = "CLEAN",
+    SET_QUESTION_PARAMS = "SET_QUESTION_PARAMS",
+    RESET = "REST",
+    SEND_ERROR = "SEND_ERROR",
+    SET_MEDIA_RECORDER = "setMediaRecorder",
+    SET_MIME_TYPE = "setmimeType",
+    SET_TIME_TO_START = "setTimeToStart",
+    SET_RECORDING_TIME = "setRecordingTime",
+    STOP_MEDIA_RECORDER = "stopMediaRecorder",
+    FORCE_START = "forceStart",
+    STOP_MIC = "stopMic",
+    SET_SPEED_TEST = "setSpeedTest",
+    SET_CONSTRAINT = "setConstraint",
+    SENTRY = "sentry"
+}
+export declare const enum RECORDER_SERVICE {
+    GET_MEDIA_STREAM = "getMediaStream",
+    GET_MEDIA_RECORDER = "getMediaRecorder"
+}
+export declare const enum SPEED_TEST_LEVEL {
+    LOW = 0,
+    MEDIUM = 1,
+    HIGH = 2
+}
+export {};

package/dist/esm/interfaces/storageInterface.d.ts

@@ -0,0 +1,29 @@
+export interface ITakeObj {
+    file: File[];
+    objectUrl: string;
+}
+interface IFilesQuestion {
+    [questionNumber: number]: ITakeObj[];
+}
+export interface InitialState {
+    questions: IFilesQuestion;
+    practice: IFilesQuestion;
+}
+export declare const enum EVENTS {
+    STORE_TAKE = "STORE_TAKE",
+    GET_TAKE = "GET_TAKE",
+    GET_TAKES = "GET_TAKES",
+    REMOVE_TAKES = "REMOVE_TAKES"
+}
+export declare const enum ACTIONS {
+    CONSOLE_LOG = "consoleLog",
+    STORE_TAKE = "storeTake",
+    SEND_TAKE = "sendTake",
+    SEND_TAKES = "sendTakes",
+    REMOVE_TAKES = "removeTakes"
+}
+export declare const enum TAKE_TYPES {
+    QUESTION = "question",
+    PRACTICE = "practice"
+}
+export {};

package/dist/esm/interfaces/uploaderInterface.d.ts

@@ -0,0 +1,39 @@
+import { IVideoFile } from './videoInterface';
+interface ILastUploadChunkl {
+    loaded: number;
+    timeStamp: number;
+}
+export interface InitialState {
+    isConnected: boolean;
+    currentQuestion: number | null;
+    file: File | null;
+    signedUrl: string;
+    uploadSpeed: number;
+    lastUploadChunk: ILastUploadChunkl;
+    videoId: string;
+    videoFile: IVideoFile;
+}
+export declare const enum STATES {
+    IDLE = "idle",
+    UPLOADING = "uploading",
+    GET_SIGNED_URL = "getSignedUrl",
+    UPLOAD_TO_S3 = "uploadToS3",
+    UPLOADED = "uploaded",
+    FINISHED = "finished"
+}
+export declare const enum ACTIONS {
+    SET_UPLOADED = "setUploaded",
+    CONSOLE_LOG = "consoleLog",
+    SET_CONNECTION = "setConnection",
+    SET_SIGNED_URL = "setSignedUrl",
+    SET_VIDEO_FILE = "setVideoFile",
+    INITIAL_UPLOAD_TIMESTAMP = "initialUploadTimestamp",
+    UPDATE_UPLOAD_SPEED = "updateUploadSpeed",
+    SEND_UPLOAD_PROGRESS = "sendUploadProgress",
+    UPDATE_PARENT = "updateParent",
+    SENTRY = "sentry"
+}
+export declare const enum GUARDS {
+    CAN_UPLOAD = "canUplaod"
+}
+export {};

package/dist/esm/interfaces/videoInterface.d.ts

@@ -0,0 +1,54 @@
+export interface IVideoPlatformOS {
+    architecture: number;
+    family: string;
+    version: string;
+}
+export interface IVideoPlatform {
+    description: string;
+    layout: string;
+    manufacturer: string;
+    name: string;
+    prerelease: string;
+    product: string;
+    ua: string;
+    version: string;
+    os: IVideoPlatformOS;
+}
+export interface IVideoFile {
+    completed: boolean;
+    uploaded: boolean;
+    filename: string;
+    retakes: number;
+    started: boolean;
+    videoLength?: number;
+    uploadUrl?: string;
+    question?: string;
+}
+export interface IVideo {
+    video_id: string;
+    bandwidth?: string;
+    clicked?: boolean;
+    started?: boolean;
+    completed?: boolean;
+    uploaded?: boolean;
+    jobID?: string;
+    platform?: IVideoPlatform;
+    quality?: string;
+    referrer?: string;
+    cvUrl?: string;
+    videos: IVideoFile[];
+    processTime?: number;
+    files?: string[];
+    personalInfo?: Record<string, string>;
+    language?: string;
+    gdprTimestamp?: string;
+    tracking?: {
+        reminder: number;
+        source: number;
+    };
+}
+export declare const enum VIDEO_STATUS {
+    INCOMPLETED = 0,
+    COMPLETED = 1,
+    UPLOADED = 2
+}

package/dist/esm/interfaces/widgetInterface.d.ts

@@ -0,0 +1,192 @@
+import { RefObject } from 'react';
+import { ActorRef, BaseActionObject, DoneInvokeEvent, Event, EventData, ResolveTypegenMeta, SCXML, ServiceMap, SingleOrArray, State, TypegenDisabled } from 'xstate';
+import { IConfig } from './configInterface';
+import { CAMERA_STATES_MESSAGES, INTERNET_STATES_MESSAGES, MICROPHONE_STATES_MESSAGES } from '../utils/messages.utils';
+import { TAKE_TYPES } from './storageInterface';
+import { IQuestion } from './jobInterface';
+import { IVideoError } from '../utils/errors.utils';
+declare type IUploaderRef = {
+    [uploaderRef: string]: ActorRef<DoneInvokeEvent<any>>;
+};
+export declare type ICameraStateKey = keyof typeof CAMERA_STATES_MESSAGES;
+export declare type IMicrophoneStateKey = keyof typeof MICROPHONE_STATES_MESSAGES;
+export declare type IInternetStateKey = keyof typeof INTERNET_STATES_MESSAGES;
+export declare const CAMERA_STATES: {
+    [K in ICameraStateKey]: K;
+};
+export declare const MICROPHONE_STATES: {
+    [K in IMicrophoneStateKey]: K;
+};
+export declare const INTERNET_STATES: {
+    [K in IInternetStateKey]: K;
+};
+export interface IChecksMetaObj {
+    key: 'camera' | 'microphone' | 'internet';
+    state: ICameraStateKey | IMicrophoneStateKey | IInternetStateKey;
+    message?: string;
+}
+export interface IChecksState {
+    camera: ICameraStateKey;
+    microphone: IMicrophoneStateKey;
+    internet: IInternetStateKey;
+}
+interface IChecksMessage {
+    camera: string;
+    microphone: string;
+    internet: string;
+}
+export interface InitialState {
+    speedTestResult: number;
+    config: IConfig;
+    questions: IQuestion[];
+    isConnected: boolean;
+    videoRef: RefObject<HTMLVideoElement>;
+    networkRef: ActorRef<DoneInvokeEvent<any>> | null;
+    recorderRef: ActorRef<DoneInvokeEvent<any>> | null;
+    storageRef: ActorRef<DoneInvokeEvent<any>> | null;
+    previewRef: ActorRef<DoneInvokeEvent<any>> | null;
+    uploaderRefs: IUploaderRef;
+    currentQuestion: number;
+    currentTake: number;
+    selectedTake: number | null;
+    recordingType: TAKE_TYPES;
+    checksState: IChecksState;
+    checksMessage: IChecksMessage;
+    totalFileSize: number;
+    totalUploadedFilesSize: {
+        [questionNumber: string]: number;
+    };
+    totalUploadSpeed: {
+        [questionNumber: string]: number;
+    };
+    error: IVideoError | null;
+}
+export interface IWidgetMachineProps {
+    widgetMachine: State<InitialState, DoneInvokeEvent<any>, any, {
+        value: any;
+        context: InitialState;
+    }, ResolveTypegenMeta<TypegenDisabled, DoneInvokeEvent<any>, BaseActionObject, ServiceMap>>;
+    sendToWidget: (event: SCXML.Event<DoneInvokeEvent<any>> | SingleOrArray<Event<DoneInvokeEvent<any>>>, payload?: EventData | undefined) => void;
+}
+export declare const enum STATES {
+    INIT = "init",
+    SETUP = "setup",
+    SETUP__INIT_STORAGE = "initStorage",
+    SETUP__INIT_RECORDER = "initRecorder",
+    SETUP__TEST = "test",
+    SETUP__TEST__CAMERA = "testCamera",
+    SETUP__TEST__CAMERA__WAITING = "testCameraWaiting",
+    SETUP__TEST__CAMERA__ERROR = "testCameraError",
+    SETUP__TEST__CAMERA__SUCCESS = "testCameraSuccess",
+    SETUP__TEST__MICROPHONE = "testMicrophone",
+    SETUP__TEST__MICROPHONE__WAITING = "testMicrophoneWaiting",
+    SETUP__TEST__MICROPHONE__ERROR = "testMicrophoneError",
+    SETUP__TEST__MICROPHONE__SUCCESS = "testMicrophoneSuccess",
+    SETUP__TEST__INTERNET = "testInternet",
+    SETUP__TEST__INTERNET__IDLE = "testInternetIdle",
+    SETUP__TEST__INTERNET__TESTING = "testInternetTesting",
+    SETUP__TEST__INTERNET__FINISHED = "testInternetFinished",
+    INTERVIEW = "interview",
+    INTERVIEW__INIT = "interviewInit",
+    INTERVIEW__EXPLANATION = "interviewExplanation",
+    INTERVIEW__QUESTION = "interviewQuestion",
+    INTERVIEW__VIDEO_QUESTION = "interviewVideoQuestion",
+    INTERVIEW__RECORDING = "interviewRecording",
+    PREVIEW = "preview",
+    RE_INIT_RECORDER = "reInitRecorder",
+    RE_INIT_RECORDER__NEXT_RETAKE = "reInitRecorderNextRetake",
+    RE_INIT_RECORDER__NEXT_QUESTION = "reInitRecorderNextQuestion",
+    UPLOADING = "uploading",
+    CONFIRM = "confirm",
+    FINISHED = "finished",
+    ERROR = "error"
+}
+export declare const enum ACTIONS {
+    CONSOLE_LOG = "consoleLog",
+    SET_CONNECTION = "setConnection",
+    SET_CONFIG = "getConfig",
+    SET_NEXT_QUESTION = "setNextQuestion",
+    SET_SPEED_TEST = "setSpeedTest",
+    SET_CHECKS = "setChecks",
+    SET_PRACTICE_MODE = "setPracticeMode",
+    SET_QUESTION_MODE = "setQuestionMode",
+    SPAWN_NETWORK = "spawnNetwork",
+    SPAWN_RECORDER = "spawnRecorder",
+    SPAWN_UPLOADER = "spawnUploader",
+    SPAWN_STORAGE = "spawnStorage",
+    SPAWN_PREVIEW = "spawnPreview",
+    STOP_RECORDER = "stopRecorder",
+    STOP_PREVIEW = "stopPreview",
+    STORE_TAKE = "storeTake",
+    GET_TAKE = "getTake",
+    GET_TAKES = "getTakes",
+    SEND_TAKES = "sendTakes",
+    UPDATE_VIDEO_FILE_COMPLETED = "updateVideoFileCompleted",
+    UPDATE_TOTAL_FILES_SIZE = "updateTotalFileSize",
+    UPDATE_TOTAL_UPLOADED_FILES_SIZE = "updateTotalUploadedFileSize",
+    UPDATE_QUESTION_NUMBER = "updateQuestionNumber",
+    UPDATE_RETAKES_NUMBER = "updateRetakesNumber",
+    UPDATE_AXION_AUTH = "updateAxiosAuth",
+    RECORDER_RE_INIT = "recorderReInit",
+    UPDATE_RECORDER_PARAMS = "updateRecorderParams",
+    UPDATE_TOTAL_UPLOADED = "updateTotalUploaded",
+    SET_VIDEO_ERROR = "setVideoError",
+    UPDATE_RECORDER_SPEED_TEST = "updateRecorderSpeedTest",
+    SENTRY = "sentry",
+    SET_SESSION = "setSession",
+    SESSION_EVENT = "sessionEvent",
+    REVOKE_MEMORY = "revokeMemory",
+    UPDATE_VIDEO_OBJECT = "updateVideoObject",
+    UPDATE_VIDEO_PART = "updateVideoPart"
+}
+export declare const enum EVENTS {
+    SPAWN_UPLOADER = "SPAWN_UPLOADER",
+    TEST = "TEST",
+    PRACTICE_MODE = "PRACTICE_MODE",
+    QUESTION_MODE = "QUESTION_MODE",
+    IDLE = "IDLE",
+    PREVIEW = "PREVIEW",
+    BACK = "BACK",
+    STOP_RECORDING = "STOP_RECORDING",
+    GET_TAKES = "GET_TAKES",
+    TAKE_TO_UPLOAD_RECEIVED = "TAKE_TO_UPLOAD_RECEIVED",
+    TAKES_RECEIVED = "TAKES_RECEIVED",
+    NEXT_STEP = "NEXT_STEP",
+    NEXT_QUESTION = "NEXT_QUESTION",
+    NEXT_RETAKE = "NEXT_RETAKE",
+    READY_TO_START_RECORDING = "READY_TO_START_RECORDING",
+    UPLOADER_PROGRESS = "UPLOADER_PROGRESS",
+    UPLOADER_FINISHED = "UPLOADER_FINISHED",
+    RECORDER_ERROR = "RECORDER_ERROR",
+    RETRY = "RETRY"
+}
+export declare const enum SERVICES {
+    UPDATE_VIDEO_OBJECT_CALL = "updateVideoObjectCall",
+    UPDATE_VIDEO_PART_CALL = "updateVideoPartCall"
+}
+export declare const enum GUARDS {
+    NO_STORAGE = "noStorage",
+    NO_RECORDER = "noRecorder",
+    IS_THINKING_TIME = "isThinkingTime",
+    IS_VIDEO_QUESTION = "isVideoQuestion",
+    IS_QUESTION_MODE = "isQuestionMode",
+    IS_PRACTICE_MODE = "isPracticeMod",
+    IS_NOT_LAST_TAKE = "isNotLastTake",
+    IS_LAST_INTERVIEW_QUESTION = "isLastInterviewQuestion",
+    IS_UPLOAD_FINISHED = "isUploadFinished",
+    CAN_RETEST_SPEED_CONNECTION = "canRetestSpeedConnection",
+    IS_CONNECTED = "isConnected",
+    IS_DISCONNECTED = "isDisconnected",
+    CAN_START_INTERVIEW = "canStartInterview",
+    ARE_ALL_QUESTIONS_UPLOADED = "areAllQuestionsUploaded"
+}
+export declare const enum TAGS {
+    SETUP = "setup",
+    SHOW_CAMERA = "showCamera",
+    CAN_START_RECORDING = "canStartRecording",
+    DISPLAY_OUTER_VIEW = "displayOuterView",
+    DISPLAY_QUESTION = "displayQuestion",
+    DISPLAY_QUESTIONS_LIST = "displayQuestionsList",
+    LOADING = "loading"
+}
+export {};

package/dist/esm/machines/acceleratorMachines/accUploaderMachine.d.ts

@@ -0,0 +1,6 @@
+import { DoneInvokeEvent } from 'xstate';
+import { InitialState } from '../../interfaces/uploaderInterface';
+export declare const accUploaderMachine: import("xstate").StateMachine<InitialState, any, DoneInvokeEvent<any>, {
+    value: any;
+    context: InitialState;
+}, import("xstate").BaseActionObject, import("xstate").ServiceMap, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, DoneInvokeEvent<any>, import("xstate").BaseActionObject, import("xstate").ServiceMap>>;

package/dist/esm/machines/acceleratorMachines/accWidgetMachine.d.ts

@@ -0,0 +1,6 @@
+import { DoneInvokeEvent } from 'xstate';
+import { InitialState } from '../../interfaces/widgetInterface';
+export declare const accWidgetMachine: import("xstate").StateMachine<InitialState, any, DoneInvokeEvent<any>, {
+    value: any;
+    context: InitialState;
+}, import("xstate").BaseActionObject, import("xstate").ServiceMap, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, DoneInvokeEvent<any>, import("xstate").BaseActionObject, import("xstate").ServiceMap>>;

package/dist/esm/machines/acceleratorMachines/microphoneMachine.d.ts

@@ -0,0 +1,6 @@
+import { DoneInvokeEvent } from 'xstate';
+import { InitialState } from '../../interfaces/microphoneInterface';
+export declare const microphoneMachine: import("xstate").StateMachine<InitialState, any, DoneInvokeEvent<any>, {
+    value: any;
+    context: InitialState;
+}, import("xstate").BaseActionObject, import("xstate").ServiceMap, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, DoneInvokeEvent<any>, import("xstate").BaseActionObject, import("xstate").ServiceMap>>;

package/dist/esm/machines/acceleratorMachines/networkMachine.d.ts

@@ -0,0 +1,5 @@
+import { DoneInvokeEvent } from 'xstate';
+export declare const networkMachine: import("xstate").StateMachine<{}, any, DoneInvokeEvent<any>, {
+    value: any;
+    context: {};
+}, import("xstate").BaseActionObject, import("xstate").ServiceMap, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, DoneInvokeEvent<any>, import("xstate").BaseActionObject, import("xstate").ServiceMap>>;

package/dist/esm/machines/acceleratorMachines/previewMachine.d.ts

@@ -0,0 +1,6 @@
+import { DoneInvokeEvent } from 'xstate';
+import { PreviewInterface } from '../../interfaces/previewInterface';
+export declare const previewMachine: import("xstate").StateMachine<PreviewInterface, any, DoneInvokeEvent<any>, {
+    value: any;
+    context: PreviewInterface;
+}, import("xstate").BaseActionObject, import("xstate").ServiceMap, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, DoneInvokeEvent<any>, import("xstate").BaseActionObject, import("xstate").ServiceMap>>;