@clickview/library-editor 1.1.18-rc.0 → 1.1.19-dev.0

package/dist/libs/analytics/src/utils/VideoAnalyticsTracker.d.ts

@@ -0,0 +1,50 @@
+import { Core } from "../../../common/src/backbone";
+import { CVEventsApi } from 'CVEvents';
+import { Video, AnalyticsOptions } from "../interfaces";
+export interface VideoAnalyticsTrackerOptions extends Core.ServiceOptions {
+    eventsApi: CVEventsApi;
+    video: Video;
+    captureInterval?: number;
+    analyticsOptions?: AnalyticsOptions;
+}
+export declare class VideoAnalyticsTracker extends Core.Service {
+    protected options: VideoAnalyticsTrackerOptions;
+    private eventsApi;
+    private model;
+    private captureInterval;
+    private playbackStatus;
+    constructor(options: VideoAnalyticsTrackerOptions);
+    get name(): string;
+    initialize(): void;
+    private bindListeners;
+    private unbindListeners;
+    private getChapters;
+    private queryWebplayer;
+    private onEnd;
+    private onFullScreen;
+    private onPlayerTimeUpdate;
+    private onChapterChange;
+    private updateTime;
+    private setInitialChapter;
+    private setVideoDuration;
+    private setCurrentPosition;
+    private getCurrentPositon;
+    private setCurrentChapter;
+    private setPlaybackStarted;
+    private playbackHasStarted;
+    private getWatchTime;
+    private incrementWatchTime;
+    private getNewPlaybackStatus;
+    private resetPlaybackStatus;
+    private unbindUnload;
+    private bindUnload;
+    private logUnload;
+    private logStream;
+    /**
+     * logVerbose is used for more granular logging than logStream, however as of June 2020
+     * we are only logging the simpler stream event which is the same as videoWatched in Online.
+     */
+    private logVerbose;
+    private getPlaybackData;
+    onDestroy(): void;
+}

package/dist/libs/analytics/src/utils/VideoDataFormatHelper.d.ts

@@ -0,0 +1,42 @@
+import { HashObject, Video } from "../interfaces";
+export interface VideoWatchAnalyticsEvent {
+    model: Video;
+    playbackStatus: PlaybackStatus;
+}
+export interface PlaybackStatus {
+    position: number;
+    chapter: number;
+    totalDuration: number;
+    totalWatched: number;
+    hasStarted?: boolean;
+}
+interface BaseVideoData {
+    id: string;
+    title: string;
+    trackingCode: string;
+    duration: number;
+}
+interface BaseAssocData {
+    id: string;
+    title?: string;
+}
+export interface VideoAnalyticsPayload {
+    video: BaseVideoData;
+    rating?: string;
+    series?: BaseAssocData;
+    folder?: BaseAssocData;
+    owner?: BaseAssocData;
+    playlist?: BaseAssocData;
+    playbackStatus?: PlaybackStatus;
+}
+export declare const VideoDataFormatHelper: {
+    getVideoData(options: VideoWatchAnalyticsEvent): VideoAnalyticsPayload;
+    /**
+       * Map to the same properties recorded in Online.
+       * @see _toLogMasterVideo() in AnalyticsService in Online
+       *
+       * TODO: Video origin and user channel logging - both of these need to be re-worked properly.
+       */
+    getLegacyVideoData(options: VideoWatchAnalyticsEvent): HashObject<any>;
+};
+export {};

package/dist/libs/common/src/backbone/constants/BehaviorChannels.d.ts

@@ -0,0 +1,5 @@
+export declare const BehaviorChannels: {
+    LAZY_LOAD: string;
+    POPUP: string;
+    IMAGE_SELECT: string;
+};

package/dist/libs/common/src/backbone/constants/Caches.d.ts

@@ -0,0 +1,3 @@
+export declare enum Caches {
+    Fifo = "FifoMemoryCache"
+}

package/dist/libs/common/src/backbone/constants/CommonChannels.d.ts

@@ -0,0 +1,5 @@
+export declare const CommonChannels: {
+    SHELL: string;
+    ALERT: string;
+    POPUP: string;
+};

package/dist/libs/common/src/backbone/constants/CommonServices.d.ts

@@ -0,0 +1,5 @@
+export declare const CommonServices: {
+    ALERT: string;
+    SCROLL: string;
+    LANGUAGE: string;
+};

package/dist/libs/common/src/backbone/constants/DataProviders.d.ts

@@ -0,0 +1,4 @@
+export declare enum DataProviders {
+    Ajax = "AjaxDataProvider",
+    Notifications = "NotificationsSignalRDataProvider"
+}

package/dist/libs/common/src/backbone/constants/Webplayer.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Events are mapped against those in Webplayer.
+ * @see http://gitlab.cvinternal.net/WebPlayer/WebPlayer/blob/master/ClickView.Html5.WebPlayer.Web/Scripts/CVPlayerEventsApi.js
+ */
+declare const WebplayerEvents: {
+    /**
+     * Events emitted from webplayer via CVEventsAPI
+     */
+    RECEIVE: {
+        PLAY: string;
+        PAUSE: string;
+        VIDEO_END: string;
+        VOLUME_CHANGE: string;
+        CHAPTER_CHANGE: string;
+        TIME_UPDATE: string;
+        FULLSCREEN_CHANGE: string;
+        CLIP_POINTS_UPDATE: string;
+        QUALITY_CHANGE: string;
+        QUERY_CALLBACK: string;
+        SUBTITLES_ENABLED: string;
+        SUBTITLES: string;
+        PONG: string;
+        FULLSCREEN_CLICK: string;
+        DEVICES_BTN_CLICK: string;
+    };
+    /**
+     * Events to trigger on CVEventsAPI to manage/update webplayer
+     */
+    TRIGGER: {
+        PLAY: string;
+        PAUSE: string;
+        SET_VOLUME: string;
+        NEXT_CHAPTER: string;
+        PREV_CHAPTER: string;
+        CHANGE_CHAPTER: string;
+        TOGGLE_CLIPPING: string;
+        SET_CLIP_POINTS: string;
+        CLIP: string;
+        CLEAR_CLIP: string;
+        SEEK_TO: string;
+        CONTROLS: string;
+        SUBTITLES: string;
+        SET_QUALITY: string;
+        QUERY: string;
+        ADD_LISTENER: string;
+        REMOVE_LISTENER: string;
+        PING: string;
+        TOGGLE_DEVICES_BTN: string;
+        SHOW_DEVICES_BTN: string;
+        SHOW_FS_BTN: string;
+    };
+    /**
+     * The webplayer can be queried directly for the following data.
+     * Listen on QUERY_CALLBACK for result and trigger on QUERY.
+     */
+    QUERIES: {
+        GET_AVAILABLE_QUALITIES: string;
+        GET_CURRENT_QUALITY: string;
+        IS_PAUSED: string;
+        GET_CURRENT_TIME: string;
+        GET_CHAPTERS: string;
+        HAS_METADATA_CHAPTERS: string;
+    };
+};
+export { WebplayerEvents };

package/dist/libs/common/src/backbone/core/AppLink.d.ts

@@ -0,0 +1,37 @@
+import { ObjectHash } from 'backbone';
+export interface AppLink {
+    application: string;
+    action: string;
+    args?: (string | number)[];
+    params?: string | ObjectHash;
+}
+export interface AppLinkHash {
+    [selector: string]: AppLink;
+}
+export interface AppLinkOptions {
+    replace?: boolean;
+}
+export declare const AppLinkUtility: {
+    routingStarted(): void;
+    routingEnded(): void;
+    hasActiveRoute(): boolean;
+};
+export declare const AppLinkHelper: {
+    /**
+     * Build a href string from an AppLink object
+     * @param appLink
+     */
+    getHref(appLink: AppLink): string;
+    /**
+     * This is the reverse process of extracting params out of a route.
+     * (e.g. Will take the route '/videos/:id' and an array of args = [123]
+     *  and return '/videos/123')
+     */
+    buildRoute(route: string, appLink: AppLink): string;
+    /**
+     * Manually trigger an AppLink
+     * @param appLink
+     */
+    trigger(appLink: AppLink, options?: AppLinkOptions): void;
+    getCurrentAppLink(): AppLink;
+};

package/dist/libs/common/src/backbone/core/BaseAppRouter.d.ts

@@ -0,0 +1,95 @@
+/// <reference types="backbone" />
+import * as Marionette from 'backbone.marionette';
+import { Shell } from './Shell';
+import { BaseApplication, BaseApplicationOptions } from './BaseApplication';
+import { AppLink } from './AppLink';
+import { MiddlewareFunction } from './Middleware';
+export interface ExecuteRouteOptions {
+    isAppRoute: boolean;
+}
+/**
+ * This should only ever be used by the shell
+ * creating a new instance of the AppRoute
+ */
+export interface BaseAppRouterOptions extends Marionette.AppRouterOptions {
+    appConstructor: typeof BaseApplication;
+    /**
+     * These will be passed into the appConstructor
+     * when creating an instance of the Application
+     */
+    appOptions?: BaseApplicationOptions;
+    shell: Shell;
+}
+/**
+ * Every Application must have an AppRouter
+ */
+export declare class BaseAppRouter extends Marionette.AppRouter {
+    /**
+     * A hash of urls to method names on the Application.
+     * Exactly the same implementation as Backbone Router routes
+     * except the methods exist on the Application.
+     * See http://backbonejs.org/#Router-routes
+     */
+    protected appRoutes?: Marionette.AppRoutes;
+    protected appLinks?: string[];
+    /**
+     * The channelName used to trigger the appLinks
+     * on backbone.radio. This will match the Application's
+     * channelName.
+     */
+    protected channelName?: string;
+    /**
+     * These are async middleware functions that are run
+     * before any route on this router is executed.
+     *
+     * They can be used to prevent access to a router using
+     * asyncronous code.
+     */
+    protected filters: MiddlewareFunction<AppLink>[];
+    /**
+     * See BaseAppRouterOptions above.
+     */
+    protected options?: BaseAppRouterOptions;
+    constructor(options?: BaseAppRouterOptions);
+    private bindDisposal;
+    /**
+     * Creates all the reverse route lookups
+     * and binds all the appLinks to the radio channel
+     */
+    private processAppEvents;
+    /**
+     * This is the heart of the AppRouter. Every single route both page loads
+     * and appLinks will go through this method.
+     *
+     * This will return false if onBeforeAction returns false
+     * and the window history will not be altered.
+     */
+    private executeRoute;
+    /**
+     * Instantiates and starts the application if there was
+     * not already an instance.
+     *
+     * Why is the application stores on this.controller?
+     * In Marionette AppRouters hold reference to a controller
+     * which in turn is responsibile for maintaining reference to an application.
+     * We've restructured this architecture so that AppRouters directly hold
+     * the instance of the Application, but are still leveraging Marionette's
+     * use of appRoutes on the controller.
+     */
+    private createApp;
+    private destroyApp;
+    /**
+     * Overriding Marionette.AppRouter's _addAppRoute so that
+     * execute route is called instead of the method directly.
+     *
+     * We do this so that executeRoute can be called for every single
+     * route, whether it's a page load or an appLink. This will make it easier
+     * to modify the action
+     */
+    private _addAppRoute;
+    private toEventName;
+    private toMethodName;
+    private validateAppLink;
+    listenTo(object: any, eventMap: Backbone.EventMap): this;
+    listenTo(obj: string | Backbone.Events, events: string, callback: Function): this;
+}

package/dist/libs/common/src/backbone/core/BaseApplication.d.ts

@@ -0,0 +1,76 @@
+import { ObjectHash } from 'backbone';
+import * as Marionette from 'backbone.marionette';
+import { Shell } from './Shell';
+import { BaseLayoutView, BaseLayoutViewOptions } from './BaseLayoutView';
+import { LayoutService, LayoutOptions } from './LayoutService';
+import { BaseAppRouter } from './BaseAppRouter';
+export interface BaseApplicationOptions extends Marionette.ApplicationOptions {
+    shell: Shell;
+    layoutService: LayoutService;
+    channelName?: string;
+}
+export declare class BaseApplication extends Marionette.Application {
+    /**
+     * Layout service is used to retreive the layout on each route
+     */
+    private layoutService;
+    /**
+     * The layout that should be used to render all content into the DOM
+     */
+    protected layout?: BaseLayoutView;
+    /**
+     * This is specified by all children of Core.Application
+     * to determine which layout to load in from layout service,
+     * and what options to instantiate it with.
+     */
+    protected layoutOptions: LayoutOptions<BaseLayoutViewOptions>;
+    /**
+     * A reference to the shell is always kept as a
+     * way to both render the layout into the dom
+     * and keep reference to global services
+     */
+    protected shell: Shell;
+    /**
+     * An instance of the Core.AppRouter is created
+     * for each Application in order to listen to applink
+     * events. The application instance is only then instantiated
+     * when the Application route is hit
+     */
+    static router: typeof BaseAppRouter;
+    /**
+     * Provides the ability to define useful error messages.
+     */
+    name: string;
+    /** When overridden determines which options are
+     * mixed into the instance */
+    props: string[];
+    /**
+     * Used by application actions to set default options.
+     */
+    private defaultQueryParams;
+    /**
+     * Shell and layoutService will be mixed into each instance
+     * of Core.Applicataion
+     */
+    get defaultProps(): string[];
+    /**
+     * The constructor will merge in props and ensure any required properties
+     * are defined
+     * @constructor
+     */
+    constructor(options?: BaseApplicationOptions);
+    private getGlobalRadioChannel;
+    /**
+     * This method is triggered by Core.AppRouter when it loads
+     * in a route for this application. It will swap in the appropriate
+     * layout before hitting the application's action.
+     *
+     */
+    private onLoadLayout;
+    private onShowPopup;
+    protected onShowAlert(options: ObjectHash): void;
+    protected setDefaultQueryParams(params: ObjectHash): void;
+    getAndClearDefaultQueryParams(): ObjectHash;
+    listenTo(object: any, eventMap: Backbone.EventMap): this;
+    listenTo(obj: string | Backbone.Events, events: string, callback: Function): this;
+}

package/dist/libs/common/src/backbone/core/BaseBehavior.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="backbone" />
+import * as Marionette from 'backbone.marionette';
+export declare class BaseBehavior extends Marionette.Behavior {
+    listenTo(object: any, eventMap: Backbone.EventMap): this;
+    listenTo(obj: string | Backbone.Events, events: string, callback: Function): this;
+}

package/dist/libs/common/src/backbone/core/BaseCollection.d.ts

@@ -0,0 +1,7 @@
+import * as Backbone from 'backbone';
+import { BaseModel } from './BaseModel';
+export declare class BaseCollection<TModel extends BaseModel = BaseModel> extends Backbone.Collection<TModel> {
+    parent?: BaseModel | BaseCollection;
+    listenTo(object: any, eventMap: Backbone.EventMap): this;
+    listenTo(obj: string | Backbone.Events, events: string, callback: Function): this;
+}

package/dist/libs/common/src/backbone/core/BaseCollectionView.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="backbone" />
+import * as Marionette from 'backbone.marionette';
+import { BaseCollection } from './BaseCollection';
+import { CoreView } from './BaseView';
+import { BaseModel } from './BaseModel';
+export interface BaseCollectionViewOptions<TModel extends BaseModel = BaseModel> extends Marionette.CollectionViewOptions<TModel> {
+    channelName?: string;
+}
+export declare class BaseCollectionView<TModel extends BaseModel = BaseModel, TView extends CoreView<TModel> = CoreView<TModel>, TCollection extends BaseCollection<TModel> = BaseCollection<TModel>> extends Marionette.CollectionView<TModel, TView, TCollection> {
+    protected options: BaseCollectionViewOptions<TModel>;
+    constructor(options?: BaseCollectionViewOptions<TModel>);
+    serializeModel(): any;
+    serializeCollection(): any[];
+    listenTo(object: any, eventMap: Backbone.EventMap): this;
+    listenTo(obj: string | Backbone.Events, events: string, callback: Function): this;
+}

package/dist/libs/common/src/backbone/core/BaseError.d.ts

@@ -0,0 +1,18 @@
+export declare class BaseError extends Error {
+    name: string;
+    constructor(message: string);
+}
+/**
+ * You can use these if you want to leverage the convenience
+ * of the error set up without actually throwing the error
+ */
+export declare abstract class SilentError extends BaseError {
+    get name(): string;
+}
+export declare class CoreError extends Error {
+    get name(): string;
+}
+declare const ErrorHelper: {
+    throw(error: BaseError): void;
+};
+export { ErrorHelper };

package/dist/libs/common/src/backbone/core/BaseLayoutView.d.ts

@@ -0,0 +1,11 @@
+import { BaseView, BaseViewOptions } from './BaseView';
+import { Store } from 'redux';
+export interface BaseLayoutViewOptions extends BaseViewOptions {
+    store?: Store;
+}
+export declare class BaseLayoutView extends BaseView {
+    protected options: BaseLayoutViewOptions;
+    constructor(options: BaseLayoutViewOptions);
+    static getCacheKey(options: BaseLayoutViewOptions): string;
+    unmountRegion(regionName: string): void;
+}

package/dist/libs/common/src/backbone/core/BaseModel.d.ts

@@ -0,0 +1,27 @@
+import * as Backbone from 'backbone';
+import { BaseCollection } from './BaseCollection';
+export declare class BaseModel extends Backbone.Model {
+    parent?: BaseModel | BaseCollection;
+    collection: BaseCollection;
+    /**
+     * Mechanism to allow properties/functions to be attached to
+     * the instance of a model at runtime.
+     * @param propertyHash
+     *
+     * I feel like this implementation is a bit naive,
+     * but it will suffice for the time being - Mike
+     */
+    private mixin;
+    /**
+     * Helper to facilitate model validation at runtime
+     * @param validation
+     */
+    addValidation(validation: any): void;
+    /**
+     * Backbone Validation mixin functions
+     */
+    preValidate: (attr: any, value: any) => any;
+    validate(attributes?: any, options?: any): any;
+    listenTo(object: any, eventMap: Backbone.EventMap): this;
+    listenTo(obj: string | Backbone.Events, events: string, callback: Function): this;
+}

package/dist/libs/common/src/backbone/core/BaseNestedModel.d.ts

@@ -0,0 +1,21 @@
+import { ModelSetOptions, ObjectHash } from 'backbone';
+import { BaseModel } from './BaseModel';
+import { BaseCollection } from './BaseCollection';
+interface Association {
+    new (...args: any[]): (BaseCollection | BaseModel);
+}
+export interface BaseNestedModelOptions extends ModelSetOptions {
+    unset?: boolean;
+}
+export declare class BaseNestedModel extends BaseModel {
+    [name: string]: any;
+    protected associations: {
+        [name: string]: Association;
+    };
+    set(key: string | object, value?: any | ModelSetOptions, options?: BaseNestedModelOptions): BaseNestedModel;
+    get(attributeName: string): any;
+    setAssociation(key: string, value: any, options: BaseNestedModelOptions): BaseModel | BaseCollection<BaseModel>;
+    toJSON(...args: any[]): ObjectHash;
+    toFlatJSON(...args: any[]): ObjectHash;
+}
+export {};

package/dist/libs/common/src/backbone/core/BaseService.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="backbone" />
+import * as Marionette from 'backbone.marionette';
+export interface BaseServiceOptions extends Marionette.ObjectOptions {
+}
+export declare class BaseService extends Marionette.Object {
+    name: string;
+    constructor(options?: BaseServiceOptions);
+    listenTo(object: any, eventMap: Backbone.EventMap): this;
+    listenTo(obj: string | Backbone.Events, events: string, callback: Function): this;
+}

package/dist/libs/common/src/backbone/core/BaseView.d.ts

@@ -0,0 +1,127 @@
+import * as Backbone from 'backbone';
+import * as Marionette from 'backbone.marionette';
+import { StickitBinding } from "../interfaces/StickitBinding";
+import { BaseModel } from './BaseModel';
+import { AppLinkHash } from './AppLink';
+interface UIHash {
+    [selector: string]: any;
+}
+export interface RequiredResourceHash {
+    [propName: string]: RequiredResourceDefinition;
+}
+export interface RequiredResourceDefinition<T = any> {
+    dataServiceName: string;
+    eventName: string;
+    getData: (instance: any) => T;
+    getInstance: (context: Backbone.Events) => any;
+    beforeOnBeforeRender: boolean;
+}
+export interface BaseViewOptions<TModel extends BaseModel = BaseModel> extends Marionette.ViewOptions<TModel> {
+    channelName?: string;
+}
+export declare class CoreView<TModel extends BaseModel = BaseModel> extends Marionette.View<TModel> {
+    /**
+     * This is of the name class. It should be used on
+     * all warnings and errors to make debugging easier.
+     */
+    name: string;
+    /**
+     * Takes a Handlebars template function.
+     */
+    template: any;
+    /**
+     * Specify the properties you want to be
+     * taken from `options` and added to the context.
+     */
+    props: string[];
+    /**
+     * This is what the page title will be set to
+     * when this view is rendered.
+     */
+    title: string | boolean;
+    /**
+     * The default properties that will be taken
+     * from `options` and added to the context.
+     */
+    private get defaultProps();
+    viewModel: BaseModel;
+    private static ViewDataExtensions;
+    /**
+     * Update instance options to include defaults. Passing options
+     * to the view via the ctor will always override defaults.
+     * @param options
+     */
+    private _setOptions;
+    /**
+     * Mix in the class name into the dom attributes to
+     * help us out with debugging
+     */
+    private _setAttributes;
+    private uiStorage;
+    get ui(): Backbone.ObjectHash;
+    set ui(value: Backbone.ObjectHash);
+    get elements(): Backbone.ObjectHash;
+    protected defaults: Backbone.ObjectHash;
+    protected options: BaseViewOptions<TModel>;
+    /**
+     * Base class for all views to inherit from.
+     * @constructor
+     */
+    constructor(options?: BaseViewOptions<TModel>);
+    appLinks: AppLinkHash;
+    normalizeUIKeys: (hash: UIHash) => UIHash;
+    static AddViewDataExtension(ext: Function | Backbone.ObjectHash): void;
+    serializeModel(): any;
+    serializeCollection(): any[];
+    /**
+     * This is a utility that can be used if your
+     * className is dynamic between renders.
+     * Simply call this.resetClassName() in
+     * onRender()
+     */
+    protected resetClassName(): void;
+    serializeData(): any;
+    protected viewOptions(): Backbone.ObjectHash;
+    /**
+     * Ensures that multiple click events arent bound
+     * if the view is getting re-rendered.
+     */
+    private undelegateAppLinks;
+    /**
+     * This will take the appLinks hash defined on a view and used it to add
+     * hrefs to the anchor tags and provide the application linking.
+     */
+    protected renderAppLinks(): void;
+    private hasPartialLoadingRegions;
+    protected renderPartialLoading(region?: string): void;
+    listenTo(object: any, eventMap: Backbone.EventMap): this;
+    listenTo(obj: string | Backbone.Events, events: string, callback: Function): this;
+    render(): CoreView<TModel>;
+    /** backbone.stickit stuff that is mixed in at run time.
+     *
+     * TODO: This should ideally be handled higher up that BaseView,
+     * (yet another one of those TODOs that is likely
+     *  to sit here till the end of time. - Sha)
+     */
+    bindings: {
+        [selector: string]: StickitBinding;
+    };
+    stickit: (model?: BaseModel, options?: any) => void;
+    addbinding: (model: BaseModel, selector: string, configuration: any) => void;
+    unstickit: (model?: BaseModel, options?: any) => void;
+    protected processRequriedResources(beforeOnBeforeRender: boolean): boolean;
+    protected setTitle(): void;
+}
+export declare class BaseView<TModel extends BaseModel = BaseModel> extends CoreView<TModel> {
+    private boundListeners;
+    private resourceInstances;
+    requiredResources: {
+        [propName: string]: RequiredResourceDefinition;
+    };
+    constructor(options?: BaseViewOptions<TModel>);
+    protected processRequriedResources(beforeOnBeforeRender: boolean): boolean;
+    setTitle(): void;
+}
+export declare class BaseComponent<TModel extends BaseModel = BaseModel> extends CoreView<TModel> {
+}
+export {};

package/dist/libs/common/src/backbone/core/EventNames.d.ts

@@ -0,0 +1,16 @@
+declare const EventNames: {
+    SHOW_POPUP: string;
+    ROUTE: string;
+    LOCK_NAV: string;
+    UNLOCK_NAV: string;
+    NAV_IS_LOCKED: string;
+    NAV_UNLOCKED_BY_USER: string;
+    ROUTING_START: string;
+    ROUTING_END: string;
+    HAS_ACTIVE_ROUTE: string;
+    ROUTE_LOOKUP: string;
+    URL_CHANGE: string;
+    ERROR: string;
+    CURRENT_ROUTE: string;
+};
+export { EventNames };