@clickview/player 0.0.3-dev-us.7 → 0.0.3-dev.0

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

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { InteractionProps, InteractionState } from 'projects/player/plugins/interactive-plugin/interfaces';
+export declare type InteractionComponent = (props: InteractionProps<InteractionState>) => React.ReactElement;

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

@@ -0,0 +1,16 @@
+import { HtmlPortalNode } from 'react-reverse-portal';
+import { CurrentUser, Interaction } from 'libs/shared/interfaces';
+export interface InteractionProps<T> {
+    interaction: Interaction;
+    state: T;
+    setState: (value: T, clear?: boolean) => void;
+    recalculateScroll?: () => void;
+    showFeedback: boolean;
+    optionsPortalNode?: HtmlPortalNode;
+    /**
+     * Used for setting the avatar on the selected
+     * multiple choice or true or false answer
+     */
+    currentUser?: CurrentUser;
+    imageApi?: URL;
+}

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

@@ -0,0 +1,4 @@
+export interface InteractionResult {
+    actionableItemId: string;
+    value: string;
+}

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

@@ -0,0 +1,4 @@
+export declare enum InteractiveMode {
+    View = 0,
+    Create = 1
+}

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

@@ -0,0 +1,28 @@
+/**
+ * When adding properties to InteractionState
+ * please make sure to omit them from ViewInteractionState below
+ * and submitInteractionAnswer() in useStateManager.tsx
+ */
+export interface InteractionState {
+    error?: string;
+    hasChanges?: boolean;
+    spinner?: boolean;
+    submitted?: boolean;
+}
+export interface ViewInteractionState extends Omit<InteractionState, 'hasChanges' | 'spinner' | 'submitted'> {
+}
+export interface CreateInteractionState extends Omit<InteractionState, 'hasChanges' | 'spinner' | 'submitted'> {
+}
+export interface TimepointState {
+    interactionIndex?: number;
+    nextInteractionIndex?: number;
+    slideIn?: boolean;
+}
+export interface InteractiveState {
+    interactions: {
+        [key: string]: InteractionState;
+    };
+    timepoints: {
+        [key: string]: TimepointState;
+    };
+}

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

@@ -0,0 +1,2 @@
+import { InteractionResult } from 'projects/player/plugins/interactive-plugin/interfaces';
+export declare type ResultSubmission = (interactionId: string, results: InteractionResult[]) => Promise<void>;

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

@@ -0,0 +1,4 @@
+import { Interaction } from 'libs/shared/interfaces';
+import { CreateInteractionState, ViewInteractionState, ResultSubmission } from 'projects/player/plugins/interactive-plugin/interfaces';
+export declare type CreateSubmissionFunction = (state: CreateInteractionState, interaction: Interaction) => Promise<void>;
+export declare type ViewSubmissionFunction = (state: ViewInteractionState, interaction: Interaction, save: ResultSubmission) => Promise<void>;

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

@@ -0,0 +1,7 @@
+export * from './InteractiveMode';
+export * from './InteractionProps';
+export * from './InteractionComponent';
+export * from './SubmissionFunction';
+export * from './InteractionResult';
+export * from './ResultSubmission';
+export * from './InteractiveState';

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

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

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

@@ -0,0 +1,24 @@
+import { InteractionResult } from 'projects/player/plugins/interactive-plugin/interfaces';
+interface ResultsServiceOptions {
+    playerApi?: URL;
+    interactiveId: string;
+    mediaId: string;
+    userId: string;
+}
+export declare class ResultsService {
+    private options;
+    private connection;
+    private resultId;
+    private cache;
+    private isConnected;
+    private retryCount;
+    constructor(options: ResultsServiceOptions);
+    start(): void;
+    stop(): Promise<void>;
+    private log;
+    private reconnect;
+    private startSession;
+    private flush;
+    save(interactionId: string, results: InteractionResult[]): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,3 @@
+import { InteractionTypeId } from 'libs/shared/interfaces';
+import { InteractionComponent, InteractiveMode } from 'projects/player/plugins/interactive-plugin/interfaces';
+export declare function getInteractionComponent(typeId: InteractionTypeId, mode: InteractiveMode): InteractionComponent;

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

@@ -0,0 +1,2 @@
+import { Interaction } from 'libs/shared/interfaces';
+export declare function getInteractionStateId(interaction: Interaction): string;

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

@@ -0,0 +1,2 @@
+import { Timepoint } from 'libs/shared/interfaces';
+export declare function getTimepointStateId(timepoint: Timepoint): string;

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

@@ -0,0 +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

@@ -0,0 +1,9 @@
+import { Interaction, Timepoint } from 'libs/shared/interfaces';
+declare class InteractiveAjaxSingleton {
+    saveInteraction(interaction: Interaction): Promise<void>;
+    deleteInteraction(id: string): Promise<void>;
+    saveTimepoint(timepoint: Timepoint): Promise<void>;
+    deleteTimepoint(id: string): Promise<void>;
+}
+export declare const InteractiveAjax: InteractiveAjaxSingleton;
+export {};

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

@@ -0,0 +1,12 @@
+import { LocalCacheAddress } from 'projects/player/interfaces/models/PlaybackObject';
+export declare class LocalCache {
+    name: string;
+    playbackProfile?: string;
+    address: URL;
+    constructor(address: LocalCacheAddress);
+    getUrl(url: string): string;
+    /**
+     * Pings the local cache. Returns true if the local cache is accessible
+     */
+    ping(): Promise<boolean>;
+}

package/dist/projects/player/src/plugins/localcache-plugin/compontents/local-cache-indicator.d.ts

@@ -0,0 +1 @@
+import './local-cache-indicator.scss';

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

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

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

@@ -0,0 +1,62 @@
+import { LocalCacheAddress } from 'projects/player/interfaces/models/PlaybackObject';
+import videojs, { VideoJsPlayer } from 'video.js';
+import { LocalCache } from './LocalCache';
+import 'projects/player/plugins/localcache-plugin/localcache-middleware';
+import 'projects/player/plugins/localcache-plugin/compontents/local-cache-indicator';
+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 LocalCachePluginOptions {
+    localCacheAddresses: LocalCacheAddress[];
+    enabled: boolean;
+}
+export declare class LocalCachePlugin extends Plugin {
+    private localCaches_;
+    private activeLocalCache_;
+    private enabled_;
+    private logger_;
+    constructor(player: VideoJsPlayer, options?: LocalCachePluginOptions);
+    get isEnabled(): boolean;
+    /**
+     * Enable local cache support
+     */
+    enable(): void;
+    /**
+     * Disable local cache support
+     */
+    disable(): void;
+    /**
+     * Get the active local cache
+     */
+    getActiveLocalCache(): Promise<LocalCache | null>;
+    /**
+     * Resets the active local cache and starts the checks to find a new active local cache
+     */
+    resetActiveLocalCache(): void;
+    /**
+     * Clears the active local cache
+     */
+    clearActiveLocalCache(): void;
+    dispose(): void;
+    private initialize;
+    private onPlayerError;
+    private getActiveLocalCacheInternal;
+    private onLocalCacheChange;
+}
+declare module 'video.js' {
+    interface VideoJsPlayer {
+        localCache(options?: LocalCachePluginOptions): LocalCachePlugin;
+    }
+}
+export {};

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

@@ -0,0 +1 @@
+import './up-next.scss';

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

@@ -0,0 +1,44 @@
+import videojs, { VideoJsPlayer } from 'video.js';
+import { NextVideo } from 'projects/player/interfaces/NextVideo';
+import 'projects/player/plugins/next-video-plugin/components/up-next/up-next';
+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 NextVideoPlugin extends Plugin {
+    private shouldPlayNextVideo;
+    private hasLocalStorage;
+    private chapterTrack;
+    private upNextRendered;
+    private upNextTimepoint;
+    private nextVideo;
+    private callback;
+    constructor(player: VideoJsPlayer);
+    private initialize;
+    setNextVideo(nextVideo: NextVideo, callback: () => void): void;
+    getShouldPlayNext(): boolean;
+    setShouldPlayNext(val: boolean): void;
+    private setChapterTrack;
+    private bindListeners;
+    private unbindListeners;
+    private onTimeUpdate;
+    private showUpNext;
+    private hideUpNext;
+    private testHasLocalStorage;
+}
+declare module 'video.js' {
+    interface VideoJsPlayer {
+        nextVideoPlugin(): NextVideoPlugin;
+    }
+}
+export {};

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

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

package/dist/projects/player/src/plugins/open-externally-plugin/interfaces/ExternalLinkOptions.d.ts

@@ -0,0 +1,3 @@
+export interface ExternalLinkOptions {
+    currentTime: number;
+}

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

@@ -0,0 +1 @@
+import 'projects/player/plugins/open-externally-plugin/components/open-externally-button';

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

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

package/dist/projects/player/src/plugins/persist-volume-plugin/persist-volume-plugin.test.d.ts

@@ -0,0 +1 @@
+import '../../plugins/persist-volume-plugin/persist-volume-plugin';

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

@@ -0,0 +1,48 @@
+import videojs, { VideoJsPlayer } from 'video.js';
+import './picture-in-picture.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 PictureInPicturePluginOptions {
+    initialIsInPictureInPicture: boolean;
+    onRequestPictureInPicture: (isPiP: boolean) => void;
+}
+declare class PictureInPicturePlugin extends Plugin {
+    private options;
+    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;
+    dispose(): void;
+}
+declare module 'video.js' {
+    interface VideoJsPlayer {
+        pictureInPicture(options?: PictureInPicturePluginOptions): PictureInPicturePlugin;
+        requestPictureInPicture(): void;
+        exitPictureInPicture(): void;
+        isInPictureInPicture(isPiP?: boolean): boolean | void;
+    }
+}
+export {};

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/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 {};