@clickview/player 0.0.4-rc.0 → 0.0.4-rc.2

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

@@ -0,0 +1,68 @@
+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;
+}
+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/progressive-files-plugin/ProgressiveFilesPluginOptions.d.ts

@@ -0,0 +1,4 @@
+import { Source } from 'projects/player/plugins/progressive-files-plugin/interfaces/Source';
+export interface ProgressiveFilesPluginOptions {
+    sources: Source[];
+}

package/dist/projects/player/src/plugins/progressive-files-plugin/ProgressiveRepresentation.d.ts

@@ -0,0 +1,10 @@
+import { Representation } from 'videojs-contrib-quality-levels';
+import { Source } from 'projects/player/plugins/progressive-files-plugin/interfaces/Source';
+import { ProgressiveFilesPlugin } from 'projects/player/plugins/progressive-files-plugin/progressive-files-plugin';
+export declare class ProgressiveRepresentation implements Representation {
+    id: string;
+    private plugin;
+    private source;
+    constructor(plugin: ProgressiveFilesPlugin, source: Source);
+    enabled(enabled: boolean): boolean;
+}

package/dist/projects/player/src/plugins/progressive-files-plugin/interfaces/Source.d.ts

@@ -0,0 +1,6 @@
+export interface Source {
+    id: string;
+    url: string;
+    mimeType: string;
+    default: boolean;
+}

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

@@ -0,0 +1,38 @@
+import videojs, { VideoJsPlayer } from 'video.js';
+import { Source } from 'projects/player/plugins/progressive-files-plugin/interfaces/Source';
+import { ProgressiveFilesPluginOptions } from 'projects/player/plugins/progressive-files-plugin/ProgressiveFilesPluginOptions';
+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;
+};
+export declare class ProgressiveFilesPlugin extends Plugin {
+    private sources;
+    private _currentSource;
+    private qualityLevels;
+    constructor(player: VideoJsPlayer, options: ProgressiveFilesPluginOptions);
+    get currentSource(): Source;
+    /**
+     * Sets the current player source. If the id cannot be found, the current source is returned
+     * @param id the id of the source to set
+     */
+    setSource(id: string): Source;
+    getSourceById(id: string): Source;
+    private populateSources;
+    private sourceChangeUpdateQualityLevels;
+}
+declare module 'video.js' {
+    interface VideoJsPlayer {
+        progressiveFiles(options: ProgressiveFilesPluginOptions): void;
+    }
+}
+export {};

package/dist/projects/player/src/plugins/resources-plugin/components/resource-menu-item/resource-menu-item.d.ts

@@ -0,0 +1,21 @@
+import videojs, { VideoJsPlayer } from 'video.js';
+import { Resource as PlayerResource } from 'projects/player/interfaces/models/PlaybackObject';
+import './resource-menu-item.scss';
+interface ResourceMenuItemProps {
+    resource: PlayerResource;
+    imageCdnUrl: string;
+}
+declare const ClickableComponent: {
+    new (player: VideoJsPlayer, options?: videojs.ComponentOptions): videojs.ClickableComponent;
+    prototype: videojs.ClickableComponent;
+};
+interface ResourceMenuItemOptions extends videojs.ComponentOptions, ResourceMenuItemProps {
+    downloadResource: (resource: PlayerResource) => void;
+}
+export declare class ResourceMenuItem extends ClickableComponent {
+    options_: ResourceMenuItemOptions;
+    constructor(player: VideoJsPlayer, options: ResourceMenuItemOptions);
+    createEl(): Element;
+    handleClick(event: videojs.EventTarget.Event): void;
+}
+export {};

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

@@ -0,0 +1 @@
+import './resources-button.scss';

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

@@ -0,0 +1,12 @@
+import 'projects/player/plugins/resources-plugin/components/resources-button/resources-button';
+import { Resource } from 'projects/player/interfaces/models/PlaybackObject';
+interface ResourcesPluginOptions {
+    resources: Resource[];
+    imageCdnUrl: string;
+}
+declare module 'video.js' {
+    interface VideoJsPlayer {
+        resourcesPlugin(options: ResourcesPluginOptions): void;
+    }
+}
+export {};

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

@@ -0,0 +1,59 @@
+import videojs, { VideoJsPlayer } from 'video.js';
+import './touch-controls.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 TouchControls extends Component {
+    private el_;
+    private timeoutId;
+    constructor(player: VideoJsPlayer, options?: videojs.ComponentOptions);
+    buildCSSClass(): string;
+    createEl(tagName?: string, properties?: any, attributes?: any): Element;
+    setUi(amount: number, timeout: number): void;
+    removeText(): void;
+}
+export {};

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

@@ -0,0 +1 @@
+import './components/touch-controls/touch-controls';

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;
+};

package/dist/projects/player/src/plugins/whiteboard-mode-plugin/interfaces/WhiteboardSide.d.ts

@@ -0,0 +1 @@
+export declare type WhiteboardSide = 'top' | 'bottom' | 'left' | 'right';

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

@@ -0,0 +1,34 @@
+import videojs, { VideoJsPlayer } from 'video.js';
+import { WhiteboardSide } from './interfaces/WhiteboardSide';
+import './whiteboard-mode.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;
+};
+declare class WhiteboardModePlugin extends Plugin {
+    side: WhiteboardSide;
+    private button;
+    constructor(player: VideoJsPlayer);
+    private initialize;
+    private initCollapserator;
+    private initDragTargets;
+    private initFullscreenListener;
+    setWhiteboardMode(side: WhiteboardSide): void;
+    private update;
+}
+declare module 'video.js' {
+    interface VideoJsPlayer {
+        whiteboardModePlugin(): WhiteboardModePlugin;
+    }
+}
+export {};

package/dist/projects/player/src/react/CreateClipPlayer.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { CreateClipPlayerOptions } from 'projects/player/players/create-clip-player';
+export declare function ClickViewCreateClipPlayer(props: CreateClipPlayerOptions): React.ReactElement;

package/dist/projects/player/src/react/InteractivePlayer.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { InteractivePlayer, InteractivePlayerOptions } from 'projects/player/players/interactive-player';
+interface ClickViewInteractivePlayerProps {
+    onReady?: (player: InteractivePlayer) => void;
+    className?: string;
+}
+export declare function ClickViewInteractivePlayer(props: InteractivePlayerOptions & ClickViewInteractivePlayerProps): React.ReactElement;
+export {};

package/dist/projects/player/src/react/Player.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { Player, PlayerOptions } from 'projects/player/players/player';
+export interface ClickViewPlayerProps extends Omit<PlayerOptions, 'playerApi'> {
+    playerApi?: URL;
+    className?: string;
+    onReady?: (player: Player) => void;
+    onError?: (error: any) => void;
+    onDispose?: () => void;
+}
+export declare function ClickViewPlayer(props: ClickViewPlayerProps): React.ReactElement;

package/dist/projects/player/src/react/react-component.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import videojs, { VideoJsPlayer } from 'video.js';
+import { HashObject } from 'libs/common/react/interfaces';
+declare type BaseReactComponentCtor<T> = new (player: VideoJsPlayer, options?: T) => videojs.Component;
+interface RootNodeOptions {
+    tagName?: string;
+    properties?: any;
+    attributes?: any;
+}
+export declare function getReactComponent<T extends HashObject>(componentCtor: (player: VideoJsPlayer, options?: T) => React.ReactElement, options?: RootNodeOptions): BaseReactComponentCtor<T>;
+export {};

package/dist/projects/player/src/services/analytics-service.d.ts

@@ -0,0 +1,31 @@
+import { RegionName } from 'libs/analytics/enums/RegionName';
+import { RegionalUrl } from 'libs/analytics/interfaces';
+import { ProgressEvent } from 'projects/player/plugins/progress-reporter-plugin/progress-reporter-plugin';
+export declare type AnalyticsPlayerType = 'player' | 'interactive-player' | 'create-clip-player';
+interface AnalyticsServiceOptions {
+    collectionApiUrls: RegionalUrl;
+    collectionApiClientId: string;
+    productVersion: string;
+    regionName: RegionName;
+    videoId: string;
+    userId: string;
+    customerId: string;
+    mediaType: 'MasterVideo' | 'MasterClip' | 'MasterInteractive';
+    playerType: AnalyticsPlayerType;
+    isEmbedded: boolean;
+    isUsingLocalCache: boolean;
+}
+export declare class AnalyticsService {
+    private options;
+    private collectionApiClient;
+    constructor(options: AnalyticsServiceOptions);
+    logStream(): void;
+    logVideoProgress(events: ProgressEvent[]): void;
+    private initialize;
+    private setupCollectionApiClient;
+    private getCurrentUser;
+    private getActionContext;
+    private getEntityType;
+    private getLocationContext;
+}
+export {};

package/dist/projects/player/src/utils/ajax-helper.d.ts

@@ -0,0 +1,16 @@
+export interface AjaxOptions {
+    tokenName?: TokenNames;
+}
+declare type TokenNames = 'gateway';
+declare class StaticAjaxHelper {
+    private tokens?;
+    get<T>(url: string, options?: AjaxOptions): Promise<T>;
+    delete(url: string, options?: AjaxOptions): Promise<void>;
+    post<T>(url: string, body: any, options?: AjaxOptions): Promise<T>;
+    put<T>(url: string, body: any, options?: AjaxOptions): Promise<T>;
+    setToken(name: TokenNames, token: string): void;
+    private getHeaders;
+    private parseResponse;
+}
+export declare const AjaxHelper: StaticAjaxHelper;
+export {};

package/dist/projects/player/src/utils/fn.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Wraps the given function, `fn`, with a new function that only invokes `fn`
+ * at most once per every `wait` milliseconds.
+ *
+ * @function
+ * @param    {Function} fn
+ *           The function to be throttled.
+ *
+ * @param    {number}   wait
+ *           The number of milliseconds by which to throttle.
+ *
+ * @return   {Function}
+ */
+export declare const throttle: (fn: any, wait: any) => any;
+/**
+ * Creates a debounced function that delays invoking `func` until after `wait`
+ * milliseconds have elapsed since the last time the debounced function was
+ * invoked.
+ *
+ * Inspired by lodash and underscore implementations.
+ *
+ * @function
+ * @param    {Function} func
+ *           The function to wrap with debounce behavior.
+ *
+ * @param    {number} wait
+ *           The number of milliseconds to wait after the last invocation.
+ *
+ * @param    {boolean} [immediate]
+ *           Whether or not to invoke the function immediately upon creation.
+ *
+ * @param    {Object} [context=window]
+ *           The "context" in which the debounced function should debounce. For
+ *           example, if this function should be tied to a Video.js player,
+ *           the player can be passed here. Alternatively, defaults to the
+ *           global `window` object.
+ *
+ * @return   {Function}
+ *           A debounced function.
+ */
+export declare const debounce: (func: any, wait: any, immediate: any, context?: any) => {
+    (...args: any[]): void;
+    cancel: () => void;
+};

package/dist/projects/player/src/utils/formatTime.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Direct copy from format-time.js within video.js
+ * Unfortunately video.js doesn't expose this
+ */
+export declare function formatTime(seconds: number, guide?: number): string;

package/dist/projects/player/src/utils/hotkeys.d.ts

@@ -0,0 +1,5 @@
+/**
+ * handleHotKeys is to be used as userActions.hotkeys in VideoJsPlayerOptions.
+ * `this` will be a reference to the player.
+ */
+export declare function handleHotKeys(event: KeyboardEvent): void;

package/dist/projects/player/src/utils/local-storage-helper.d.ts

@@ -0,0 +1,6 @@
+export declare const LocalStorageHelper: {
+    hasLocalStorage: () => boolean;
+    get: (key: string) => string;
+    set: (key: string, value: string) => void;
+    remove: (key: string) => void;
+};

package/dist/projects/player/src/utils/quality-helper.d.ts

@@ -0,0 +1,19 @@
+import { QualityLevel, QualityLevelList } from 'videojs-contrib-quality-levels';
+export declare class QualityHelper {
+    /**
+     * Returns a list of known profiles, ordered from best to worst
+     */
+    static getKnownProfiles(): string[];
+    /**
+     * Enables the provided profile, or the next best option
+     * @param qualities
+     * @param profile The profile which we want to select
+     */
+    static enableProfileOrNextBest(qualities: QualityLevelList, profile: string): QualityLevel | null;
+    /**
+     * Gets the next best quality for the given profile
+     * @param qualities
+     * @param profile
+     */
+    private static getNextBestQuality;
+}

package/dist/projects/player/src/utils/quality-helper.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/projects/player/src/utils/scrollbar-helper.d.ts

@@ -0,0 +1,6 @@
+import videojs from 'video.js';
+export declare const ScrollbarHelper: {
+    initMenuScrollbar(component: videojs.MenuButton): void;
+    unMountScrollbar(component: videojs.MenuButton): void;
+    getMenuEl(component: videojs.MenuButton): HTMLElement;
+};

package/dist/projects/player/src/utils/track-helper.d.ts

@@ -0,0 +1,8 @@
+import { VideoJsPlayer } from 'video.js';
+declare type TrackKind = 'metadata' | 'chapters';
+declare type TrackLabel = 'interactive' | 'thumbnails' | false;
+export declare const TrackHelper: {
+    useTrack(player: VideoJsPlayer, kind: TrackKind, label: TrackLabel, callback: (track: TextTrack) => void): void;
+    getCurrentTextTrack(player: VideoJsPlayer): TextTrack;
+};
+export {};

package/dist/projects/player/test/players/test-player.d.ts

@@ -0,0 +1,17 @@
+import { VideoJsPlayer } from 'video.js';
+import { BasePlayer, BasePlayerOptions } from '../../src/players/base-player';
+export interface TestPlayerOptions extends BasePlayerOptions {
+    configurePlugins?: (player: VideoJsPlayer) => void;
+}
+export declare class TestPlayer extends BasePlayer {
+    protected options: TestPlayerOptions;
+    player: VideoJsPlayer;
+    constructor(id: string | Element, options: TestPlayerOptions);
+    /**
+     * TODO: Look at reimplementing this. At the moment it's causing
+     * problems because the test will dispose of the player before the
+     * fetch has completed.
+     */
+    protected fetch(): Promise<void>;
+    protected configurePlugins(): void;
+}