@myinterview/widget-react 1.0.311 → 1.1.0

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

@@ -0,0 +1,231 @@
+import { RefObject } from 'react';
+import { ActorRef, BaseActionObject, DoneInvokeEvent, Event, EventData, ResolveTypegenMeta, SCXML, ServiceMap, SingleOrArray, State, TypegenDisabled } from 'xstate';
+import { IWidgetConfig } from './configInterface';
+import { CAMERA_STATES_MESSAGES, INTERNET_STATES_MESSAGES, MICROPHONE_STATES_MESSAGES } from '../utils/messages.utils';
+import { TAKE_TYPES } from './storageInterface';
+import { ALL_JOB_QUESTIONS_TYPE } from './jobInterface';
+import { IVideoError } from '../utils/errors.utils';
+import { IVideoDimensions } from './videoInterface';
+type IUploaderRef = {
+    [uploaderRef: string]: ActorRef<DoneInvokeEvent<any>>;
+};
+export declare const VIDEO_ERROR_MESSAGES: {
+    RETRY: "RETRY";
+    REDIRECT: "REDIRECT";
+    NO_ERROR: "";
+};
+export type ICameraStateKey = keyof typeof CAMERA_STATES_MESSAGES;
+export type IMicrophoneStateKey = keyof typeof MICROPHONE_STATES_MESSAGES;
+export type IInternetStateKey = keyof typeof INTERNET_STATES_MESSAGES;
+export type IVideoCorruptedMessagesKey = keyof typeof VIDEO_ERROR_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 declare const VIDEO_CORRUPTED_STATES: {
+    [K in IVideoCorruptedMessagesKey]: 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;
+    widgetConfig: IWidgetConfig;
+    questions: ALL_JOB_QUESTIONS_TYPE[];
+    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;
+    countDownRef: ActorRef<DoneInvokeEvent<any>> | null;
+    timer: number;
+    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;
+    failedRecordingAttempts: number;
+    failedRecordingMessage: IVideoCorruptedMessagesKey;
+    isResumed: boolean;
+    videoDimensions: IVideoDimensions;
+}
+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",
+    WELCOME = "welcome",
+    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__ANSWER_SELECTOR = "interviewAnswerSelector",
+    INTERVIEW__ASSESSMENT = "interviewAssessment",
+    INTERVIEW__RECORDING = "interviewRecording",
+    PREVIEW = "preview",
+    NEXT_QUESTION_MIDDLEWARE = "nextQuestionMiddleware",
+    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",
+    CONSOLE_DEBUG = "consoleDebug",
+    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",
+    SPAWN_COUNT_DOWN = "spawnCountDown",
+    STOP_RECORDER = "stopRecorder",
+    STOP_PREVIEW = "stopPreview",
+    STOP_COUNT_DOWN = "stopCountDown",
+    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_TIMER = "updateTimer",
+    UPDATE_AXION_AUTH = "updateAxiosAuth",
+    RECORDER_RE_INIT = "recorderReInit",
+    DEACTIVATE_RECORDER = "deactivateRecorder",
+    RECORDER_RE_INIT_AUTO_START = "recorderReInitAutoStart",
+    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",
+    INCREASE_FAILED_RECORDING_ATTEMPTS = "increaseFailedRecordingAttempts",
+    RESET_FAILED_RECORDING_ATTEMPTS = "resetFailedRecordingAttempts",
+    CLEAR_VIDEO_ERROR = "clearVideoError",
+    UPDATE_VIDEO_DIMENSIONS = "updateVideoDimensions"
+}
+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",
+    UPDATE_TIMER = "UPDATE_TIMER",
+    UPDATE_VIDEO_DIMENSIONS = "UPDATE_VIDEO_DIMENSIONS"
+}
+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",
+    CAN_RETEST_SPEED_CONNECTION = "canRetestSpeedConnection",
+    IS_CONNECTED = "isConnected",
+    IS_DISCONNECTED = "isDisconnected",
+    CAN_START_INTERVIEW = "canStartInterview",
+    ARE_ALL_QUESTIONS_UPLOADED = "areAllQuestionsUploaded",
+    SHOULD_SHOW_WELCOME = "shouldShowWelcome",
+    IS_NO_SOUND_ERROR = "isNoSoundError",
+    IS_VIDEO_CORRUPTED = "isVideoCorrupted",
+    IS_AUDIO_ERROR = "isAudioError",
+    IS_VIDEO_ERROR = "isVideoError",
+    THERE_ARE_NO_VIDEO_QUESTIONS_TYPE = "thereAreNoVideoQuestionType",
+    IS_RECORDER_READY = "isRecorderReady",
+    IS_ASSESSMENT_QUESTION = "isAssessmentQuestion"
+}
+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/cjs/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/cjs/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/cjs/machines/acceleratorMachines/counterMachine.d.ts

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

package/dist/cjs/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/cjs/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/cjs/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>>;

package/dist/cjs/machines/acceleratorMachines/recorderMachineV2.d.ts

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

package/dist/cjs/machines/acceleratorMachines/storageMachine.d.ts

@@ -0,0 +1,6 @@
+import { DoneInvokeEvent } from 'xstate';
+import { InitialState } from '../../interfaces/storageInterface';
+export declare const storageMachine: 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/cjs/reportWebVitals.d.ts

@@ -0,0 +1,3 @@
+import { ReportHandler } from 'web-vitals';
+declare const reportWebVitals: (onPerfEntry?: ReportHandler) => void;
+export default reportWebVitals;

package/dist/cjs/services/axiosInstances.service.d.ts

@@ -0,0 +1,4 @@
+export declare const videoAxiosInstance: import("axios").AxiosInstance;
+export declare const s3AxiosInstance: import("axios").AxiosInstance;
+export declare const updateVideoAxiosAuth: (auth: string) => void;
+export declare const updateVideoAxiosBaseURL: (url: string) => void;

package/dist/cjs/services/s3.service.d.ts

@@ -0,0 +1 @@
+export declare const uploadToS3: (url: string, data: File, onProgress?: ((e: any) => void) | undefined, timeout?: number) => Promise<void>;

package/dist/cjs/services/session.service.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @author tht7 ( tht7 )
+ * @date 10/07/12022 6:36 pm
+ */
+import { ICandidateSession } from '../interfaces/candidateSessionInterface';
+/**
+ * This function will update the session in the database and cache it in the window object
+ * it will fill in the current session over the provided object
+ * @param session
+ * @param baseURL
+ */
+export declare function updateSession(session: Partial<ICandidateSession>, baseURL?: string): Promise<ICandidateSession | undefined>;
+/**
+ * This function will fetch the session from the sessionStorage and server
+ * it will then cache the session in the window object
+ * @param _session - in case you want to override the session, or save a new one to the cache
+ * @param _session_id - in case you want to override the session_id and fetch from the server
+ */
+export declare function getCandidateSession(_session?: ICandidateSession, _session_id?: string): Promise<ICandidateSession | undefined>;
+export declare function getSessionIdFromCache(): string | undefined | null;
+/**
+ * this will remove the session from the sessionStorage, but not the window cache
+ * this should signal the end of this session
+ * however the end of a session is when the window gets closed
+ * so in order to prevent a new window from (maybe) getting the stale session
+ * we remove it from the sessionStorage
+ */
+export declare function deleteSession(): void;
+/** ehehehe this is a type that takes 2 types and matches all the keys of type V from type K */
+type KeysMatching<T, V> = {
+    [K in keyof T]-?: T[K] extends (V | undefined) ? K : never;
+}[keyof T];
+/**
+ * A cute shortcut for updating a date event in the session
+ * just give it the key of the date event, and it will update it
+ * @param eventType
+   */
+export declare function registerDateEvent(eventType: KeysMatching<ICandidateSession, Date>): Promise<ICandidateSession | undefined>;
+/**
+ * Another cute shortcut for updating a number state of a session
+ * if no data is provided, it will just increment the number
+ * @param eventType
+ * @param data
+ */
+export declare function registerCountEvent(eventType: KeysMatching<ICandidateSession, number>, data?: number): Promise<ICandidateSession | undefined>;
+/**
+ * Another cute shortcut for updating a number state of a session
+ * if no data is provided, it will just increment the number
+ * @param warning
+ */
+export declare function registerWarning(warning: string): Promise<ICandidateSession | undefined>;
+export declare const triggerEvent: {
+    warning: typeof registerWarning;
+    date: typeof registerDateEvent;
+    number: typeof registerCountEvent;
+};
+export {};

package/dist/cjs/services/speedTest.service.d.ts

@@ -0,0 +1,2 @@
+export declare const ONE_MB_IN_BYTES = 1048576;
+export declare const accSpeedTest: () => Promise<number>;

package/dist/cjs/services/video.service.d.ts

@@ -0,0 +1,7 @@
+import { IWidgetConfigRequest, IWidgetConfigResponse } from '../interfaces/configInterface';
+import { IVideo, ALL_VIDEO_FILE_TYPES, IVideoDimensions } from '../interfaces/videoInterface';
+export declare const createVideo: (widgetConfig: IWidgetConfigRequest) => Promise<IWidgetConfigResponse>;
+export declare const getVideo: (videoId: string) => Promise<IWidgetConfigResponse>;
+export declare const updateVideo: ({ video_id, started, completed, uploaded, bandwidth }: IVideo) => Promise<IWidgetConfigResponse>;
+export declare const updateVideoFile: (videoId: string, videoFile: ALL_VIDEO_FILE_TYPES) => Promise<IWidgetConfigResponse>;
+export declare const getUploadUrl: (videoId: string, fileName: string, typeExtension: string, { width, height }: IVideoDimensions) => Promise<IWidgetConfigResponse>;

package/dist/cjs/setupTests.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';

package/dist/cjs/utils/authToken.utils.d.ts

@@ -0,0 +1,7 @@
+interface IGetToken {
+    type: string;
+    value: string;
+    secretKey: string;
+}
+export declare const getToken: ({ type, value, secretKey }: IGetToken) => string;
+export {};

package/dist/cjs/utils/constants.utils.d.ts

@@ -0,0 +1,21 @@
+export declare const DEFAULT_COUNT_DOWN = 3;
+export declare const DEFAULT_DURATION = 60;
+export declare const DEFAULT_ATTEMPTS = 3;
+export declare const DEFAULT_THINKING_TIME = 0;
+export declare const ENOUGH_RECORDING_TIME = 3;
+export declare const SPEED_TEST_FILE_SIZE = 5;
+export declare const FAST_UPLOAD_SPEED = 0.35;
+export declare const SLOW_UPLOAD_SPEED = 0.1;
+export declare const SPEED_TEST_TIMEOUT = 5000;
+export declare const VIDEO_INACTIVE_TIMEOUT = 2000;
+export declare const MICROPHONE_NO_SOUND_ERROR_CODE = 777;
+export declare const MAX_FAILED_RECORDING_ATTEMPTS = 2;
+export declare const MICROPHONE_RETAKE_COUNT = 100;
+export declare const SECONDS_LEFT_HIGHLIGHT = 10;
+export declare const DEFAULT_ASSESSMENT_MAX_CHARS = 300;
+export declare const DEFAULT_ASSESSMENT_DURATION = 0;
+export declare const DEFAULT_VIDEO_DIMENSIONS: {
+    width: number;
+    height: number;
+};
+export declare const FONT_URL = "https://fonts.googleapis.com/css2?family=Nunito+Sans:wght@400;600;700&display=swap";

package/dist/cjs/utils/convertor.utils.d.ts

@@ -0,0 +1,2 @@
+import { IClientQuestion, IQuestion } from '../interfaces/jobInterface';
+export declare const convertQuestions: (questions?: IClientQuestion[]) => IQuestion[];

package/dist/cjs/utils/debug.utils.d.ts

@@ -0,0 +1,19 @@
+export declare const enum DEBUG {
+    FETCHING_INTERVIEW = "Fetching interview data",
+    INTERVIEW_DATA_RECEIVED = "Interview data received",
+    FETCHING_INTERVIEW_ERROR = "Failed to fetch interview",
+    WELCOME_PAGE_STAGE = "In welcome page stage",
+    SETUP_STAGE = "In setup stage",
+    MEIDA_DEVICE_SUCCESS = "Media device available",
+    MEDIA_DEVICE_ERROR = "Media device error",
+    NO_SOUND_DETECTED = "No sound detected",
+    DEVICE_CHANGED = "Device changed",
+    SPEED_TEST_DONE = "Speed test result received",
+    PRACTICE_STARTED = "Practice started",
+    INTERVIEW_STARTED = "Interview started",
+    RETAKE_CLICKED = "Retake clicked",
+    QUESTION_SUBMITTED = "Qeustion submitted",
+    UPLOADING_STATE = "In uploading state",
+    UPLOAD_COMPLETED = "Upload completed",
+    INTERVIEW_SUBMITTED = "Interview submitted successfully"
+}

package/dist/cjs/utils/device.utils.d.ts

@@ -0,0 +1,12 @@
+export declare const isMobile: boolean;
+export declare const isAndroid: boolean;
+export declare const isSupportedIosDevice: boolean;
+export declare const isSupportedDevice: boolean;
+declare const PLATFORMS_OPTIONS: readonly ["ANDROID", "IOS", "MACBOOK", "WINDOWS"];
+declare const BROWSERS_OPTIONS: readonly ["CHROME", "SAFARI", "FIREFOX", "SAMSUNG"];
+type DEVICE_TYPE = {
+    PLATFORM: typeof PLATFORMS_OPTIONS[number];
+    BROWSER: typeof BROWSERS_OPTIONS[number];
+};
+export declare const DEVICE: DEVICE_TYPE;
+export {};

package/dist/cjs/utils/errors.utils.d.ts

@@ -0,0 +1,9 @@
+import { STATUS_CODES } from './statusCodes.utils';
+export interface IVideoError {
+    callId: string;
+    errorCode: number;
+    errorMessage: string;
+    statusCode: STATUS_CODES;
+    statusReason: string;
+    time: number;
+}

package/dist/cjs/utils/formatters.utils.d.ts

@@ -0,0 +1,5 @@
+export declare const twoDigitsNumber: (num: number) => string;
+export declare const timeFormatter: (number: number) => string;
+export declare const timeLeftInMinutesFormatter: (number: number) => string;
+export declare const timerCountDown: (number: number) => string[];
+export declare const formattedDuration: (number: number) => string;

package/dist/cjs/utils/languages.utils.d.ts

@@ -0,0 +1 @@
+export declare const isRtl: (language?: string) => boolean;

package/dist/cjs/utils/messages.utils.d.ts

@@ -0,0 +1,16 @@
+export declare const CAMERA_STATES_MESSAGES: {
+    WAITING: string;
+    ERROR: string;
+    READY: string;
+};
+export declare const MICROPHONE_STATES_MESSAGES: {
+    WAITING: string;
+    ERROR: string;
+    READY: string;
+};
+export declare const INTERNET_STATES_MESSAGES: {
+    DISCONNECTED: string;
+    TESTING: string;
+    SLOW_CONNECTION: string;
+    CONNECTED: string;
+};

package/dist/cjs/utils/recorderErrors.utils.d.ts

@@ -0,0 +1,29 @@
+export declare const TYPES_EXPLANATION: {
+    VIDEO: string;
+    AUDIO: string;
+    VIDEO_AUDIO: string;
+};
+export declare const enum MEDIA_RECORDER_STATES {
+    INACTIVE = "inactive",
+    RECORDING = "recording",
+    PAUSED = "paused"
+}
+export declare const ERROR_ENUM: {
+    NotAllowedError: string;
+    NotFoundError: string;
+    NotReadableError: string;
+    AbortError: string;
+    OverconstrainedError: string;
+    SecurityError: string;
+    TypeError: string;
+    NoSoundError: string;
+    UndefinedError: string;
+    VideoCorrupted: string;
+};
+export declare const recorderErrors: {
+    [x: string]: {
+        type: string;
+        message: string;
+        name: string;
+    };
+};

package/dist/cjs/utils/sentry.utils.d.ts

@@ -0,0 +1,6 @@
+import * as Sentry from '@sentry/browser';
+import { DoneInvokeEvent } from 'xstate';
+import { Breadcrumb } from '@sentry/types';
+export declare const SentryHub: Sentry.Hub;
+export declare const SentryTrackingFn: (event: DoneInvokeEvent<any>, context: any, name: string, level: 'fatal' | 'error' | 'warning' | 'log' | 'info' | 'debug') => void;
+export declare const SentryBreadcrumb: ({ type, level, event_id, category, message, data }: Breadcrumb) => void;

package/dist/cjs/utils/statusCodes.utils.d.ts

@@ -0,0 +1,13 @@
+export declare const enum STATUS_CODES {
+    OK = 200,
+    CREATED = 201,
+    DELETED = 202,
+    BAD_REQUEST = 400,
+    UNAUTHORIZED = 401,
+    PAYMENT_REQUIRED = 402,
+    FORBIDDEN = 403,
+    NOT_FOUND = 404,
+    TOO_MANY_REQUESTS = 429,
+    SERVER_ERROR = 500,
+    SERVICE_UNAVAILABLE = 503
+}

package/dist/cjs/workers/microphone.worker.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => void;
+export default _default;

package/dist/cjs/workers/worker-builder.d.ts

@@ -0,0 +1,3 @@
+export default class Builder extends Worker {
+    constructor(worker: Worker);
+}

package/dist/esm/App.d.ts

@@ -1,2 +1,3 @@
 import React from 'react';
+import './assets/styles/global.scss';
 export declare const App: React.FC;

package/dist/esm/components/AnswerInstructions.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { ASSESSMENT_QUESTIONS_TYPE } from '../interfaces/jobInterface';
+interface IProps {
+    currentQuestionObj: ASSESSMENT_QUESTIONS_TYPE;
+}
+export declare const AnswerInstructions: React.FC<IProps>;
+export {};

package/dist/esm/components/AssessmentController.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { ASSESSMENT_QUESTIONS_TYPE } from '../interfaces/jobInterface';
+import { IMultipleAnswer } from '../interfaces/videoInterface';
+interface IProps {
+    currentQuestionObj: ASSESSMENT_QUESTIONS_TYPE;
+    currentQuestion: number;
+    numberOfQuestions: number;
+    timer: number;
+    onSubmitAssessment: (answer: IMultipleAnswer[] | string) => void;
+}
+export declare const AssessmentController: React.FC<IProps>;
+export {};

package/dist/esm/components/AssessmentFreeText.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface IProps {
+    onAnswer: (answer: string) => void;
+    maxChars?: number;
+}
+export declare const AssessmentFreeText: React.FC<IProps>;
+export {};

package/dist/esm/components/AssessmentMultiSelect.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { IMultipleChoiceOptionDefinition } from '../interfaces/jobInterface';
+import { IMultipleAnswer } from '../interfaces/videoInterface';
+interface IProps {
+    answerOptions: IMultipleChoiceOptionDefinition[];
+    onAnswer: (answers: IMultipleAnswer[]) => void;
+}
+export declare const AssessmentMultiSelect: React.FC<IProps>;
+export {};

package/dist/esm/components/AssessmentSingleSelect.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { IMultipleChoiceOptionDefinition } from '../interfaces/jobInterface';
+import { IMultipleAnswer } from '../interfaces/videoInterface';
+interface IProps {
+    answerOptions: IMultipleChoiceOptionDefinition[];
+    onAnswer: (answer: IMultipleAnswer[]) => void;
+}
+export declare const AssessmentSingleSelect: React.FC<IProps>;
+export {};

package/dist/esm/components/CharactersLimit.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface IProps {
+    currentLength: number;
+    maxLength: number;
+}
+export declare const CharactersLimit: React.FC<IProps>;
+export {};

package/dist/esm/components/CountDown.d.ts

@@ -1,6 +1,8 @@
 /// <reference types="react" />
 interface CountDownProps {
     countDown: number;
+    forceMobileCounter?: boolean;
+    numberOfSecondsToHighlight?: number;
 }
-export declare const CountDown: ({ countDown }: CountDownProps) => JSX.Element;
+export declare const CountDown: ({ countDown, forceMobileCounter, numberOfSecondsToHighlight }: CountDownProps) => JSX.Element;
 export {};

package/dist/esm/components/DeviceSelector.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="react" />
+import React from 'react';
 import { mediaDeviceType } from '../interfaces/recorderInterface';
 export interface IDeviceSelectorProps {
     handleDeviceChange: (type?: mediaDeviceType, id?: string) => void;
@@ -6,5 +6,6 @@ export interface IDeviceSelectorProps {
     videoDevices?: MediaDeviceInfo[];
     selectedAudioDevice?: MediaDeviceInfo;
     selectedVideoDevice?: MediaDeviceInfo;
+    myinterviewRef: React.RefObject<HTMLDivElement>;
 }
-export declare const DeviceSelector: ({ handleDeviceChange, videoDevices, audioDevices, selectedAudioDevice, selectedVideoDevice, }: IDeviceSelectorProps) => JSX.Element;
+export declare const DeviceSelector: ({ handleDeviceChange, videoDevices, audioDevices, selectedAudioDevice, selectedVideoDevice, myinterviewRef, }: IDeviceSelectorProps) => JSX.Element;