@clickview/player 0.0.2 → 0.0.3-dev-us.2

package/dist/projects/player/src/plugins/interactive-plugin/components/view-components/missing-word/missing-word-interaction.d.ts

@@ -1,10 +1,12 @@
 import React from 'react';
 import { Interaction } from 'libs/shared/interfaces';
 import { InteractionProps, ViewInteractionState, ViewSubmissionFunction } from 'projects/player/plugins/interactive-plugin//interfaces';
+import { InteractionCorrectness } from 'libs/shared/enums/InteractionCorrectness';
 import './missing-word-interaction.scss';
 interface MissingWordState extends ViewInteractionState {
     [id: string]: string;
 }
+export declare function IsMissingWordCorrect(state: MissingWordState, interaction: Interaction): InteractionCorrectness;
 export declare function IsViewMissingWordValid(state: MissingWordState, interaction: Interaction): string;
 export declare const SubmitViewMissingWord: ViewSubmissionFunction;
 export declare function MissingWordInteraction(props: InteractionProps<MissingWordState>): React.ReactElement;

package/dist/projects/player/src/plugins/interactive-plugin/components/view-components/multiple-choice/multiple-choice-interaction.d.ts

@@ -1,9 +1,12 @@
 import React from 'react';
+import { Interaction } from 'libs/shared/interfaces';
 import { InteractionProps, ViewInteractionState, ViewSubmissionFunction } from 'projects/player/plugins/interactive-plugin/interfaces';
 import './multiple-choice-interaction.scss';
+import { InteractionCorrectness } from 'libs/shared/enums/InteractionCorrectness';
 interface MultipleChoiceState extends ViewInteractionState {
     [id: string]: string;
 }
+export declare function IsMultipleChoiceCorrect(state: MultipleChoiceState, interaction: Interaction): InteractionCorrectness;
 export declare function IsViewMultipleChoiceValid(state: MultipleChoiceState): string;
 export declare const SubmitViewMultipleChoice: ViewSubmissionFunction;
 export declare function MultipleChoiceInteraction(props: InteractionProps<MultipleChoiceState>): React.ReactElement;

package/dist/projects/player/src/plugins/interactive-plugin/components/view-components/true-or-false/true-or-false-interaction.d.ts

@@ -1,9 +1,12 @@
 import React from 'react';
+import { Interaction } from 'libs/shared/interfaces';
 import { InteractionProps, ViewInteractionState, ViewSubmissionFunction } from 'projects/player/plugins/interactive-plugin/interfaces';
+import { InteractionCorrectness } from 'libs/shared/enums/InteractionCorrectness';
 import './true-or-false-interaction.scss';
 interface MultipleChoiceState extends ViewInteractionState {
     [id: string]: string;
 }
+export declare function IsTrueOrFalseCorrect(state: MultipleChoiceState, interaction: Interaction): InteractionCorrectness;
 export declare function IsViewTrueOrFalseValid(state: MultipleChoiceState): string;
 export declare const SubmitViewTrueOrFalse: ViewSubmissionFunction;
 export declare function TrueOrFalseInteraction(props: InteractionProps<MultipleChoiceState>): React.ReactElement;

package/dist/projects/player/src/plugins/interactive-plugin/components/view-components/view-components.d.ts

@@ -1,9 +1,12 @@
 import { Interaction, InteractionTypeId } from 'libs/shared/interfaces';
 import { InteractionComponent, ViewInteractionState, ViewSubmissionFunction } from 'projects/player/plugins/interactive-plugin/interfaces';
+import { InteractionCorrectness } from 'libs/shared/enums/InteractionCorrectness';
 declare type ShowFeedbackFunction = (interaction: Interaction) => boolean;
 export declare function getShouldShowFeedback(typeId: InteractionTypeId): ShowFeedbackFunction;
 export declare function getViewComponent(typeId: InteractionTypeId): InteractionComponent;
 declare type ViewValidationFunction = (state: ViewInteractionState, interaction: Interaction) => string;
 export declare function getViewValidation(typeId: InteractionTypeId): ViewValidationFunction;
 export declare function getViewSubmit(typeId: InteractionTypeId): ViewSubmissionFunction;
+declare type IsCorrectFunction = (state: ViewInteractionState, interaction: Interaction) => InteractionCorrectness;
+export declare function getViewIsCorrect(typeId: InteractionTypeId): IsCorrectFunction;
 export {};

package/dist/projects/player/src/plugins/interactive-plugin/hooks/useInteractiveState.d.ts

@@ -1,20 +1,26 @@
 import { Timepoint } from 'libs/shared/interfaces';
-import { InteractionState, InteractiveMode, TimepointState } from 'projects/player/plugins/interactive-plugin/interfaces';
+import { InteractionState, InteractiveMode, LatestSession, TimepointState } from 'projects/player/plugins/interactive-plugin/interfaces';
 interface UseInteractiveStateProps {
     mode: InteractiveMode;
     timepoint: Timepoint;
+    latestSession?: LatestSession;
 }
+/**
+ * This should only be used inside of useStateManager
+ */
 export declare const useInteractiveState: (props: UseInteractiveStateProps) => {
-    _doNotUse: import("../interfaces").InteractiveState;
+    state: import("../interfaces").InteractiveState;
     interaction: import("../../../../../../libs/shared/src/interfaces").Interaction;
     interactionState: InteractionState;
     timepointState: TimepointState;
+    nextInteraction: import("../../../../../../libs/shared/src/interfaces").Interaction;
+    nextInteractionState: InteractionState;
     getTimepointState: (id: string) => TimepointState;
     getInteractionState: (id: string) => InteractionState;
     updateTimepointState: (id: string, value: TimepointState) => void;
-    updateInteractionState: (id: string, value: InteractionState) => void;
+    updateInteractionState: (id: string, value: InteractionState, clear?: boolean) => void;
     clearTimepointState: (id: string) => void;
     clearInteractionState: (id: string) => void;
-    userUpdateInteractionState: (value: InteractionState) => void;
+    userUpdateInteractionState: (value: InteractionState, clear?: boolean) => void;
 };
 export {};

package/dist/projects/player/src/plugins/interactive-plugin/hooks/useInteractiveTrack.d.ts

@@ -16,5 +16,6 @@ export declare const useInteractiveTrack: (options: useInteractiveOptions) => {
     updateCue: (oldTimepointId: string, timepointId: string) => void;
     addCue: (timepointId: string) => void;
     removeCue: (visibleAt: number) => void;
+    moveTimepoint: (newTime: number) => void;
 };
 export {};

package/dist/projects/player/src/plugins/interactive-plugin/hooks/useLockPlayer.d.ts

@@ -1,14 +1,14 @@
 import { VideoJsPlayer } from 'video.js';
 import { Interaction, Timepoint } from 'libs/shared/interfaces';
 import { InteractiveMode } from 'projects/player/plugins/interactive-plugin/interfaces';
-import { InteractionState, InteractiveState } from 'projects/player/plugins/interactive-plugin/interfaces/InteractiveState';
+import { InteractionState, TimepointState } from 'projects/player/plugins/interactive-plugin/interfaces/InteractiveState';
 interface UseLockNavProps {
     mode: InteractiveMode;
-    state: InteractiveState;
     player: VideoJsPlayer;
     timepoint: Timepoint;
     interaction: Interaction;
     interactionState: InteractionState;
+    timepointState: TimepointState;
     discardChanges: (after?: () => void) => void;
 }
 export declare function useLockPlayer(props: UseLockNavProps): void;

package/dist/projects/player/src/plugins/interactive-plugin/hooks/useStateManager.d.ts

@@ -1,6 +1,6 @@
 import { VideoJsPlayer } from 'video.js';
 import { Interaction, InteractionTypeId, Interactive, Timepoint } from 'libs/shared/interfaces';
-import { InteractiveMode } from 'projects/player/plugins/interactive-plugin/interfaces';
+import { InteractiveMode, LatestSession } from 'projects/player/plugins/interactive-plugin/interfaces';
 import { ResultsService } from 'projects/player/plugins/interactive-plugin/utils/ResultsService';
 interface UseStateManagerProps {
     mode: InteractiveMode;
@@ -8,23 +8,27 @@ interface UseStateManagerProps {
     interactive: Interactive;
     player: VideoJsPlayer;
     resultsService?: ResultsService;
+    latestSession?: LatestSession;
     setOpen: (open: boolean) => void;
     addCue: (timepointId: string) => void;
     updateCue: (oldTimepointId: string, timepointId: string) => void;
     removeCue: (visibleAt: number) => void;
     continueInteractive: () => void;
+    moveTimepoint: (newTime: number) => void;
 }
 export declare const useStateManager: (props: UseStateManagerProps) => {
-    _doNotUse: import("../interfaces").InteractiveState;
+    state: import("../interfaces").InteractiveState;
     interaction: Interaction;
     interactionState: import("../interfaces").InteractionState;
     timepointState: import("../interfaces").TimepointState;
+    nextInteraction: Interaction;
+    nextInteractionState: import("../interfaces").InteractionState;
     skip: () => void;
     cancel: () => Promise<void>;
     addAnotherQuestion: () => void;
     goToTimepoint: (timepointId: string, interactionId: string) => void;
     discardChanges: (afterDiscard?: () => void) => void;
-    changeIndex: (interactionIndex: number) => void;
+    changeIndex: (interactionIndex: number, prompt?: boolean) => void;
     promptDelete: (interactionId: string) => void;
     showTypeSelector: () => void;
     cancelTypeSelector: () => void;
@@ -32,6 +36,10 @@ export declare const useStateManager: (props: UseStateManagerProps) => {
     saveInteraction: () => Promise<void>;
     addInteraction: (typeId: InteractionTypeId) => void;
     submitInteractionAnswer: () => Promise<void>;
-    userUpdateInteractionState: (value: import("../interfaces").InteractionState) => void;
+    userUpdateInteractionState: (value: import("../interfaces").InteractionState, clear?: boolean) => void;
+    updateTimepointTime: (time: number) => void;
+    saveTimepoint: () => Promise<void>;
+    clearTimepointTimeState: (reset?: boolean) => void;
+    reOrderQuestions: (interactions: Interaction[]) => Promise<void>;
 };
 export {};

package/dist/projects/player/src/plugins/interactive-plugin/interactive-plugin.d.ts

@@ -1,2 +1,49 @@
+import videojs, { VideoJsPlayer } from 'video.js';
+import { HtmlPortalNode } from 'react-reverse-portal';
+import { CurrentUser, Interactive } from 'libs/shared/interfaces';
+import { InteractiveMode, LatestSession } from 'projects/player/plugins/interactive-plugin/interfaces';
+import { ResultsService } from 'projects/player/plugins/interactive-plugin/utils/ResultsService';
+import { ProgressEvent } from 'projects/player/plugins/progress-reporter-plugin/progress-reporter-plugin';
 import 'projects/player/plugins/interactive-plugin/components/interactive/interactive-component';
+import 'projects/player/plugins/interactive-plugin/components/continue-session/continue-session';
 import './interactive-plugin-styles.scss';
+declare const Plugin: {
+    new (player: VideoJsPlayer, options?: any): videojs.Plugin;
+    prototype: videojs.Plugin;
+    BASE_PLUGIN_NAME: string;
+    deregisterPlugin(name: string): void;
+    getPlugin(name: string): any;
+    getPluginVersion(name: string): string;
+    getPlugins(names?: string[]): {
+        [name: string]: videojs.Plugin;
+    };
+    isBasic(plugin: string | (() => any)): boolean;
+    registerPlugin<T, K>(name: string, plugin: (this: VideoJsPlayer, ...options: K[]) => T): (...options: K[]) => T;
+    registerPlugin<T_1 extends any>(name: string, plugin: T_1): () => T_1;
+};
+interface InteractivePluginOptions {
+    currentUser?: CurrentUser;
+    interactive: Interactive;
+    mode?: InteractiveMode;
+    imageApi?: URL;
+    resultsService?: ResultsService;
+    questionListPortalNode?: HtmlPortalNode;
+    summaryPortalNode?: HtmlPortalNode;
+    progress?: ProgressEvent[];
+    latestSession?: LatestSession;
+}
+declare class InteractivePlugin extends Plugin {
+    private options;
+    private continueSession;
+    constructor(player: VideoJsPlayer, options: InteractivePluginOptions);
+    private initialize;
+    private startSession;
+    private onTrackLoaded;
+    private addChildren;
+}
+declare module 'video.js' {
+    interface VideoJsPlayer {
+        viewInteractivePlugin(options?: InteractivePluginOptions): InteractivePlugin;
+    }
+}
+export {};

package/dist/projects/player/src/plugins/interactive-plugin/interfaces/InteractionProps.d.ts

@@ -3,7 +3,7 @@ import { CurrentUser, Interaction } from 'libs/shared/interfaces';
 export interface InteractionProps<T> {
     interaction: Interaction;
     state: T;
-    setState: (value: T) => void;
+    setState: (value: T, clear?: boolean) => void;
     recalculateScroll?: () => void;
     showFeedback: boolean;
     optionsPortalNode?: HtmlPortalNode;

package/dist/projects/player/src/plugins/interactive-plugin/interfaces/InteractiveState.d.ts

@@ -14,7 +14,11 @@ export interface ViewInteractionState extends Omit<InteractionState, 'hasChanges
 export interface CreateInteractionState extends Omit<InteractionState, 'hasChanges' | 'spinner' | 'submitted'> {
 }
 export interface TimepointState {
-    interactionIndex: number;
+    interactionIndex?: number;
+    nextInteractionIndex?: number;
+    slideIn?: boolean;
+    originalVisibleAt?: number;
+    hasChanges?: boolean;
 }
 export interface InteractiveState {
     interactions: {

package/dist/projects/player/src/plugins/interactive-plugin/interfaces/LatestSession.d.ts

@@ -0,0 +1,11 @@
+export interface LatestSession {
+    resultId: string;
+    actions: Action[];
+}
+interface Action {
+    data: string;
+    resultId: string;
+    interactionId: string;
+    actionableItemId: string;
+}
+export {};

package/dist/projects/player/src/plugins/interactive-plugin/interfaces/index.d.ts

@@ -5,3 +5,4 @@ export * from './SubmissionFunction';
 export * from './InteractionResult';
 export * from './ResultSubmission';
 export * from './InteractiveState';
+export * from './LatestSession';

package/dist/projects/player/src/plugins/interactive-plugin/utils/InteractiveReducer.d.ts

@@ -1,4 +1,4 @@
-import { InteractionState, InteractiveState, TimepointState } from 'projects/player/plugins/interactive-plugin/interfaces';
+import { InteractionState, InteractiveState, LatestSession, TimepointState } from 'projects/player/plugins/interactive-plugin/interfaces';
 interface InteractionAction {
     type: 'interaction';
     id: string;
@@ -9,6 +9,6 @@ interface TimepointAction {
     id: string;
     value: TimepointState;
 }
-export declare const initialState: InteractiveState;
+export declare function getInitialState(latestSession: LatestSession): InteractiveState;
 export declare function interactiveReducer(state: InteractiveState, action: InteractionAction | TimepointAction): InteractiveState;
 export {};

package/dist/projects/player/src/plugins/interactive-plugin/utils/ResultsService.d.ts

@@ -13,7 +13,10 @@ export declare class ResultsService {
     private isConnected;
     private retryCount;
     constructor(options: ResultsServiceOptions);
-    start(): void;
+    /**
+     * @param resultId Allows you to continue an old interactive session
+     */
+    start(resultId?: string): void;
     stop(): Promise<void>;
     private log;
     private reconnect;

package/dist/projects/player/src/plugins/interactive-plugin/utils/helpers.d.ts

@@ -1 +1,2 @@
+export declare const SLIDING_TIME = 600;
 export declare function isNewId(id: string): boolean;

package/dist/projects/player/src/plugins/interactive-plugin/utils/interactive-ajax.d.ts

@@ -3,6 +3,7 @@ declare class InteractiveAjaxSingleton {
     saveInteraction(interaction: Interaction): Promise<void>;
     deleteInteraction(id: string): Promise<void>;
     saveTimepoint(timepoint: Timepoint): Promise<void>;
+    updateTimepoint(timepoint: Timepoint): Promise<void>;
     deleteTimepoint(id: string): Promise<void>;
 }
 export declare const InteractiveAjax: InteractiveAjaxSingleton;

package/dist/projects/player/src/plugins/next-video-plugin/next-video-plugin.d.ts

@@ -21,14 +21,6 @@ declare class NextVideoPlugin extends Plugin {
     private chapterTrack;
     private upNextRendered;
     private upNextTimepoint;
-    /**
-     * @Matt These values are intended to be used to render the up next widget
-     * and to be called when the up next widget is clicked on
-     * or the video ends.
-     *
-     * Note: Cam suggested we check if there is a chapter called "Credits"
-     * and trigger the up next widget then, rather than in the last 5 seconds
-     */
     private nextVideo;
     private callback;
     constructor(player: VideoJsPlayer);

package/dist/projects/player/src/plugins/persist-quality-settings-plugin/persist-quality-settings-plugin.d.ts

@@ -0,0 +1,33 @@
+import videojs, { VideoJsPlayer } from 'video.js';
+declare const Plugin: {
+    new (player: VideoJsPlayer, options?: any): videojs.Plugin;
+    prototype: videojs.Plugin;
+    BASE_PLUGIN_NAME: string;
+    deregisterPlugin(name: string): void;
+    getPlugin(name: string): any;
+    getPluginVersion(name: string): string;
+    getPlugins(names?: string[]): {
+        [name: string]: videojs.Plugin;
+    };
+    isBasic(plugin: string | (() => any)): boolean;
+    registerPlugin<T, K>(name: string, plugin: (this: VideoJsPlayer, ...options: K[]) => T): (...options: K[]) => T;
+    registerPlugin<T_1 extends any>(name: string, plugin: T_1): () => T_1;
+};
+interface PersistQualitySettingsPluginOptions {
+    playbackProfile: string;
+    playbackProfileLocalCache: string;
+}
+declare class PersistQualitySettingsPlugin extends Plugin {
+    private options;
+    constructor(player: VideoJsPlayer, options: PersistQualitySettingsPluginOptions);
+    private initialize;
+    private onQualityLevelsChange;
+    private isLocalCacheActive;
+    private getStorageKey;
+}
+declare module 'video.js' {
+    interface VideoJsPlayer {
+        persistQualitySettingsPlugin(options: PersistQualitySettingsPluginOptions): PersistQualitySettingsPlugin;
+    }
+}
+export {};

package/dist/projects/player/src/plugins/persist-subtitle-settings-plugin/persist-subtitle-settings-plugin.d.ts

@@ -0,0 +1,38 @@
+import videojs, { VideoJsPlayer } from 'video.js';
+import { SubtitleSizes } from 'projects/player/components/text-track-settings/text-track-settings';
+declare const Plugin: {
+    new (player: VideoJsPlayer, options?: any): videojs.Plugin;
+    prototype: videojs.Plugin;
+    BASE_PLUGIN_NAME: string;
+    deregisterPlugin(name: string): void;
+    getPlugin(name: string): any;
+    getPluginVersion(name: string): string;
+    getPlugins(names?: string[]): {
+        [name: string]: videojs.Plugin;
+    };
+    isBasic(plugin: string | (() => any)): boolean;
+    registerPlugin<T, K>(name: string, plugin: (this: VideoJsPlayer, ...options: K[]) => T): (...options: K[]) => T;
+    registerPlugin<T_1 extends any>(name: string, plugin: T_1): () => T_1;
+};
+interface PersistSubtitleSettingsPluginOptions {
+    showSubtitles: boolean;
+    subtitleSize: SubtitleSizes;
+}
+declare class PersistSubtitleSettingsPlugin extends Plugin {
+    private options;
+    private trackGuess;
+    constructor(player: VideoJsPlayer, options: PersistSubtitleSettingsPluginOptions);
+    private initialize;
+    private safeGet;
+    private onSelectedLanguageChange;
+    private bindEventListeners;
+    private onChangeSubtitleSize;
+    private guessWhichTrack;
+    private getLanguageParts;
+}
+declare module 'video.js' {
+    interface VideoJsPlayer {
+        persistSubtitleSettingsPlugin(options?: PersistSubtitleSettingsPluginOptions): PersistSubtitleSettingsPlugin;
+    }
+}
+export {};

package/dist/projects/player/src/plugins/picture-in-picture-plugin/picture-in-picture-plugin.d.ts

@@ -1,4 +1,5 @@
 import videojs, { VideoJsPlayer } from 'video.js';
+import './picture-in-picture.scss';
 declare const Plugin: {
     new (player: VideoJsPlayer, options?: any): videojs.Plugin;
     prototype: videojs.Plugin;
@@ -19,15 +20,18 @@ interface PictureInPicturePluginOptions {
 }
 declare class PictureInPicturePlugin extends Plugin {
     private options;
-    private pictureInPictureEnabled;
     private playerRequestPictureInPictureFn;
     private playerExitPictureInPictureFn;
+    private playToggle;
+    private pictureInPictureEnabled;
     constructor(player: VideoJsPlayer, options: PictureInPicturePluginOptions);
     private initialize;
     private bindFunctions;
     enablePictureInPicture(): void;
     disablePictureInPicture(): void;
     togglePictureInPicture(isInPictureInPicture: boolean): void;
+    private addPipStyles;
+    private removePipStyles;
     private requestPictureInPicture;
     private exitPictureInPicture;
     private getToggleParentComponent;

package/dist/projects/player/src/plugins/progress-reporter-plugin/progress-reporter-plugin.d.ts

@@ -1,3 +1,18 @@
+import videojs, { VideoJsPlayer } from 'video.js';
+declare const Plugin: {
+    new (player: VideoJsPlayer, options?: any): videojs.Plugin;
+    prototype: videojs.Plugin;
+    BASE_PLUGIN_NAME: string;
+    deregisterPlugin(name: string): void;
+    getPlugin(name: string): any;
+    getPluginVersion(name: string): string;
+    getPlugins(names?: string[]): {
+        [name: string]: videojs.Plugin;
+    };
+    isBasic(plugin: string | (() => any)): boolean;
+    registerPlugin<T, K>(name: string, plugin: (this: VideoJsPlayer, ...options: K[]) => T): (...options: K[]) => T;
+    registerPlugin<T_1 extends any>(name: string, plugin: T_1): () => T_1;
+};
 interface Event {
     time: number;
     type: string;
@@ -6,4 +21,48 @@ export interface ProgressEvent {
     start: Event;
     end: Event;
 }
+interface ProgressReporterPluginOptions {
+    onFlush: (events: ProgressEvent[]) => void;
+    interval?: number;
+}
+declare class ProgressReporterPlugin extends Plugin {
+    private options;
+    private eventBuffer;
+    private latestTime;
+    /**
+     * Used to clean up data while flushing the buffer
+     * It's stored on the instance because it needs to maintain state
+     * between buffers.
+     */
+    private lastPlayingTime;
+    private previousLatestTime;
+    private isPlaying;
+    private isSeeking;
+    private hasEnded;
+    /**
+     * We use our timeupdate event instead of asking for
+     * a function to add a single event listener in our options.
+     */
+    private shouldLogPlayOnTimeUpdate;
+    private pauseTimeout;
+    constructor(player: VideoJsPlayer, options: ProgressReporterPluginOptions);
+    private initialize;
+    private validateOptions;
+    private bindListeners;
+    private startInterval;
+    private onPlay;
+    private onPause;
+    private onTimeUpdate;
+    private onSeeking;
+    private onEnded;
+    private logEvent;
+    private shouldUseCarriedOverTime;
+    private shouldClearCarriedOverTime;
+    private flushBuffer;
+}
+declare module 'video.js' {
+    interface VideoJsPlayer {
+        progressReporterPlugin(options?: ProgressReporterPluginOptions): ProgressReporterPlugin;
+    }
+}
 export {};

package/dist/projects/player/src/plugins/touch-controls-plugin/components/touch-controls/touch-controls.d.ts

@@ -35,7 +35,7 @@ declare const Component: {
         new (player: VideoJsPlayer, options?: videojs.ComponentOptions, ready?: videojs.Component.ReadyCallback): videojs.Spacer;
         prototype: videojs.Spacer;
     };
-    getComponent(name: "player" | "Player"): {
+    getComponent(name: "Player" | "player"): {
         new (player: VideoJsPlayer, options?: import("video.js").VideoJsPlayerOptions): VideoJsPlayer;
         prototype: VideoJsPlayer;
         getTagSettings(tag: Element): any;

package/dist/projects/player/src/plugins/whiteboard-mode-plugin/components/drag-handle/drag-handle.d.ts

@@ -0,0 +1,53 @@
+import videojs from 'video.js';
+import './drag-handle.scss';
+declare const Component: {
+    new (player: import("video.js").VideoJsPlayer, options?: videojs.ComponentOptions, ready?: videojs.Component.ReadyCallback): videojs.Component;
+    prototype: videojs.Component;
+    getComponent(name: "Button" | "button"): {
+        new (player: import("video.js").VideoJsPlayer, options?: videojs.ComponentOptions): videojs.Button;
+        prototype: videojs.Button;
+    };
+    getComponent(name: "ClickableComponent" | "clickablecomponent"): {
+        new (player: import("video.js").VideoJsPlayer, options?: videojs.ComponentOptions): videojs.ClickableComponent;
+        prototype: videojs.ClickableComponent;
+    };
+    getComponent(name: "ModalDialog" | "modaldialog"): {
+        new (player: import("video.js").VideoJsPlayer, options?: videojs.ModalDialogOptions): videojs.ModalDialog;
+        prototype: videojs.ModalDialog;
+    };
+    getComponent(name: "Menu" | "menu"): {
+        new (player: import("video.js").VideoJsPlayer, options?: videojs.MenuOptions): videojs.Menu;
+        prototype: videojs.Menu;
+    };
+    getComponent(name: "MenuButton" | "menubutton"): {
+        new (player: import("video.js").VideoJsPlayer, options?: videojs.MenuButtonOptions): videojs.MenuButton;
+        prototype: videojs.MenuButton;
+    };
+    getComponent(name: "MenuItem" | "menuitem"): {
+        new (player: import("video.js").VideoJsPlayer, options?: videojs.MenuItemOptions): videojs.MenuItem;
+        prototype: videojs.MenuItem;
+    };
+    getComponent(name: "MouseTimeDisplay" | "mouseTimeDisplay"): {
+        new (player: import("video.js").VideoJsPlayer, options?: videojs.ComponentOptions): videojs.MouseTimeDisplay;
+        prototype: videojs.MouseTimeDisplay;
+    };
+    getComponent(name: "Spacer" | "spacer"): {
+        new (player: import("video.js").VideoJsPlayer, options?: videojs.ComponentOptions, ready?: videojs.Component.ReadyCallback): videojs.Spacer;
+        prototype: videojs.Spacer;
+    };
+    getComponent(name: "Player" | "player"): {
+        new (player: import("video.js").VideoJsPlayer, options?: import("video.js").VideoJsPlayerOptions): import("video.js").VideoJsPlayer;
+        prototype: import("video.js").VideoJsPlayer;
+        getTagSettings(tag: Element): any;
+    };
+    getComponent(name: "timeTooltip" | "TimeTooltip"): {
+        new (player: import("video.js").VideoJsPlayer, options?: videojs.ComponentOptions): videojs.TimeToolTip;
+        prototype: videojs.TimeToolTip;
+    };
+    getComponent(name: string): any;
+    registerComponent(name: string, ComponentToRegister: any): any;
+};
+export declare class DragHandle extends Component {
+    createEl(): HTMLButtonElement;
+}
+export {};

package/dist/projects/player/src/plugins/whiteboard-mode-plugin/components/drag-targets/drag-targets.d.ts

@@ -0,0 +1,54 @@
+import videojs, { VideoJsPlayer } from 'video.js';
+import './drag-targets.scss';
+declare const Component: {
+    new (player: VideoJsPlayer, options?: videojs.ComponentOptions, ready?: videojs.Component.ReadyCallback): videojs.Component;
+    prototype: videojs.Component;
+    getComponent(name: "Button" | "button"): {
+        new (player: VideoJsPlayer, options?: videojs.ComponentOptions): videojs.Button;
+        prototype: videojs.Button;
+    };
+    getComponent(name: "ClickableComponent" | "clickablecomponent"): {
+        new (player: VideoJsPlayer, options?: videojs.ComponentOptions): videojs.ClickableComponent;
+        prototype: videojs.ClickableComponent;
+    };
+    getComponent(name: "ModalDialog" | "modaldialog"): {
+        new (player: VideoJsPlayer, options?: videojs.ModalDialogOptions): videojs.ModalDialog;
+        prototype: videojs.ModalDialog;
+    };
+    getComponent(name: "Menu" | "menu"): {
+        new (player: VideoJsPlayer, options?: videojs.MenuOptions): videojs.Menu;
+        prototype: videojs.Menu;
+    };
+    getComponent(name: "MenuButton" | "menubutton"): {
+        new (player: VideoJsPlayer, options?: videojs.MenuButtonOptions): videojs.MenuButton;
+        prototype: videojs.MenuButton;
+    };
+    getComponent(name: "MenuItem" | "menuitem"): {
+        new (player: VideoJsPlayer, options?: videojs.MenuItemOptions): videojs.MenuItem;
+        prototype: videojs.MenuItem;
+    };
+    getComponent(name: "MouseTimeDisplay" | "mouseTimeDisplay"): {
+        new (player: VideoJsPlayer, options?: videojs.ComponentOptions): videojs.MouseTimeDisplay;
+        prototype: videojs.MouseTimeDisplay;
+    };
+    getComponent(name: "Spacer" | "spacer"): {
+        new (player: VideoJsPlayer, options?: videojs.ComponentOptions, ready?: videojs.Component.ReadyCallback): videojs.Spacer;
+        prototype: videojs.Spacer;
+    };
+    getComponent(name: "Player" | "player"): {
+        new (player: VideoJsPlayer, options?: import("video.js").VideoJsPlayerOptions): VideoJsPlayer;
+        prototype: VideoJsPlayer;
+        getTagSettings(tag: Element): any;
+    };
+    getComponent(name: "timeTooltip" | "TimeTooltip"): {
+        new (player: VideoJsPlayer, options?: videojs.ComponentOptions): videojs.TimeToolTip;
+        prototype: videojs.TimeToolTip;
+    };
+    getComponent(name: string): any;
+    registerComponent(name: string, ComponentToRegister: any): any;
+};
+export declare class DragTargets extends Component {
+    constructor(player: VideoJsPlayer, options?: videojs.ComponentOptions);
+    private addChildren;
+}
+export {};

package/dist/projects/player/src/plugins/whiteboard-mode-plugin/components/whiteboard-mode-button/whiteboard-mode-button.d.ts

@@ -0,0 +1,23 @@
+import { CollapsibleComponent } from 'projects/player/interfaces/CollapsibleComponent';
+import videojs from 'video.js';
+import { WhiteboardModeMenuItem } from './whiteboard-mode-menu-item';
+declare const MenuButton: {
+    new (player: import("video.js").VideoJsPlayer, options?: videojs.MenuButtonOptions): videojs.MenuButton;
+    prototype: videojs.MenuButton;
+};
+export declare class WhiteboardModeButton extends MenuButton implements CollapsibleComponent {
+    createItems(): WhiteboardModeMenuItem[];
+    buildWrapperCSSClass(): string;
+    /**
+     * CollapsibileComponent interface implementation
+     * from here onward
+     */
+    alwaysCollapsed: boolean;
+    isCollapsed: boolean;
+    isCollabsible: boolean;
+    getCollabsibleName(): string;
+    getCollabsibleValue(): string;
+    showInCollabsibleMenu(): boolean;
+    showCollapsibleMenu(): void;
+}
+export {};

package/dist/projects/player/src/plugins/whiteboard-mode-plugin/components/whiteboard-mode-button/whiteboard-mode-menu-item.d.ts

@@ -0,0 +1,15 @@
+import videojs, { VideoJsPlayer } from 'video.js';
+import { WhiteboardSide } from '../../interfaces/WhiteboardSide';
+declare const MenuItem: {
+    new (player: VideoJsPlayer, options?: videojs.MenuItemOptions): videojs.MenuItem;
+    prototype: videojs.MenuItem;
+};
+interface WhiteboardModeMenuItemOptions extends videojs.MenuItemOptions {
+    side: WhiteboardSide;
+}
+export declare class WhiteboardModeMenuItem extends MenuItem {
+    options_: WhiteboardModeMenuItemOptions;
+    constructor(player: VideoJsPlayer, options: WhiteboardModeMenuItemOptions);
+    handleClick(): void;
+}
+export {};

package/dist/projects/player/src/plugins/whiteboard-mode-plugin/contants/WhiteboardSides.d.ts

@@ -0,0 +1,5 @@
+import { WhiteboardSide } from '../interfaces/WhiteboardSide';
+export declare const WhiteboardSides: WhiteboardSide[];
+export declare const WhiteboardSideNames: {
+    [key in WhiteboardSide]: string;
+};