@clickview/player 0.0.3-dev.1 → 0.0.3-rc.1

package/dist/libs/common/src/backbone/interfaces/Pagination.d.ts

@@ -0,0 +1,33 @@
+export interface Pagination {
+    cursors: Cursors;
+    limit: number;
+}
+export interface Cursors {
+    next: string;
+    previous: string;
+}
+/**
+ * Do not extend or implement this interface.
+ * It is only exported for use within the BaseDataService.
+ *
+ * By default, the BaseDataService will convert legacy pagination
+ * objects to cursor-based pagination objects.
+ */
+export interface LegacyPagination {
+    page: number;
+    pageSize: number;
+    totalItems: number;
+    totalPages: number;
+}
+/**
+ * Do not extend or implement this interface.
+ * It is only exported for use within the BaseDataService.
+ *
+ * By default, the BaseDataService will convert legacy pagination
+ * objects to cursor-based pagination objects.
+ */
+export interface OffsetPagination {
+    offset: number;
+    pageSize: number;
+    totalItems: number;
+}

package/dist/libs/common/src/backbone/interfaces/StickitBinding.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="jquery" />
+/// <reference types="jqueryui" />
+/// <reference types="typeahead" />
+/// <reference types="bootstrap" />
+/// <reference types="dropzone" />
+import { BaseModel } from '../core/BaseModel';
+export interface StickitBinding {
+    observe: string;
+    onGet?: string | ((value: string, options: any) => string);
+    onSet?: string | ((value: string, options: any) => string);
+    getVal?: string | (($el: JQuery, event: Event, options: any) => string);
+    update?: string | (($el: JQuery, value: string, model: BaseModel, options: any) => void);
+    updateModel?: string | boolean | ((value: string, event: Event, options: any) => boolean);
+    updateView?: string | boolean | (() => boolean);
+    afterUpdate?: string | (($el: JQuery, value: string, options: any) => void);
+    updateMethod?: string;
+    escape?: boolean;
+    initialize?: string | (($el: JQuery, model: BaseModel, options: any) => void);
+    destroy?: string | (($el: JQuery, model: BaseModel, options: any) => void);
+    visible?: boolean | ((value: string, options: any) => boolean);
+    visibleFn?: string;
+    events?: string[];
+    name?: string;
+    selectOptions?: {
+        collection: string;
+        labelPath: string;
+        valuePath: string;
+        defaultOption?: string;
+    };
+    setOptions?: {
+        silent?: boolean;
+        validate?: boolean;
+    };
+    classes?: {
+        [className: string]: StickitBinding;
+    };
+    attributes?: StickitBinding[];
+}

package/dist/libs/common/src/backbone/interfaces/Xhr.d.ts

@@ -0,0 +1,9 @@
+export interface Xhr extends Pick<XMLHttpRequest, 'getResponseHeader' | 'status'> {
+    responseJSON?: any;
+}
+/**
+ * We're making getResponseHeader optional for a slightly nicer API
+ */
+export interface SimulatedXhr extends Omit<Xhr, 'getResponseHeader'> {
+    getResponseHeader?: (name: string) => string;
+}

package/dist/libs/common/src/backbone/interfaces/index.d.ts

@@ -0,0 +1,9 @@
+export * from './BaseCollectionIdentifier';
+export * from './ChainableDataService';
+export * from './DataCache';
+export * from './DataProvider';
+export * from './DataServiceError';
+export * from './DataServiceRequests';
+export * from './Pagination';
+export * from './StickitBinding';
+export * from './Xhr';

package/dist/libs/common/src/backbone/services/EnvironmentVariables.d.ts

@@ -0,0 +1,13 @@
+import { ObjectHash } from 'backbone';
+declare class StaticEnvironmentVariables {
+    private static instance;
+    private variables;
+    constructor();
+    static get Instance(): StaticEnvironmentVariables;
+    get name(): string;
+    get isDevelopment(): boolean;
+    get(name: string): any;
+    setUpVariables(variables: ObjectHash): void;
+}
+export declare const EnvironmentVariables: StaticEnvironmentVariables;
+export {};

package/dist/libs/common/src/backbone/services/LanguageService.d.ts

@@ -0,0 +1,22 @@
+import { ObjectHash } from 'backbone';
+import { BaseService } from 'libs/common/backbone/core/BaseService';
+interface LanguageInterpolationOptions {
+    smartCount?: number;
+    [propName: string]: any;
+}
+interface LanguageConfig {
+    locale: string;
+    phrases: ObjectHash;
+}
+declare class StaticLanguageService extends BaseService {
+    private static instance;
+    private polyglot;
+    private cache;
+    static get Instance(): StaticLanguageService;
+    get name(): string;
+    setConfig(config: LanguageConfig): void;
+    getPhrase(namespace: string, phraseKey: string, options?: LanguageInterpolationOptions): string;
+    encloseNamespace(namespace: string): (phraseKey: string, options?: LanguageInterpolationOptions) => string;
+}
+export declare const LanguageService: StaticLanguageService;
+export {};

package/dist/libs/common/src/backbone/utils/FunctionHelper.d.ts

@@ -0,0 +1,8 @@
+import * as _ from 'underscore';
+export declare const FunctionHelper: {
+    debounce<T extends (...args: any) => any>(fn: T, wait: number, immediate?: boolean): T & _.Cancelable;
+    throttle<T_1 extends (...args: any) => any>(fn: T_1, wait: number, options?: _.ThrottleSettings): T_1 & _.Cancelable;
+    isFunction(object: any): object is Function;
+    useIdentity<T_2>(): (...args: any[]) => T_2;
+    memoize<T_3 = (...args: any) => any>(fn: T_3, hashFn?: (...args: any[]) => string): T_3;
+};

package/dist/libs/common/src/backbone/utils/UrlHelper.d.ts

@@ -0,0 +1,14 @@
+import { ObjectHash } from 'backbone';
+interface FilterParams {
+    limit?: number;
+    cursor?: string;
+    before?: string;
+}
+export declare const UrlHelper: {
+    urlBuilder(base: string, queryStringObj: ObjectHash): string;
+    buildFilter(params: FilterParams): string;
+    makeHttps(url: string): string;
+    safeUrlConcat(baseUrl: string, path: string): string;
+    removeTrailingSlash(baseUrl: string): string;
+};
+export {};

package/dist/libs/common/src/react/flight/FlightHelpers.d.ts

@@ -0,0 +1,14 @@
+import { ApplicationState } from 'libs/common/react/interfaces/ApplicationState';
+import { Request, Response, Dispatch } from './interfaces';
+export declare function emptyResponse<T>(): Response<T>;
+export declare function getResponse<T>(state: ApplicationState, key: string): Response<T>;
+export declare function getFetch(dispatch: Dispatch, request: Request): () => void;
+export declare function fetch(dispatch: Dispatch, request: Request): void;
+export declare function hooklessFetch(dispatch: Dispatch, state: ApplicationState, request: Request): void;
+export declare function useGetFetch(request: Request): () => void;
+interface GetResponseOptions {
+    optimize: boolean;
+}
+export declare function useGetResponse<T>(key: string, options?: GetResponseOptions): Response<T>;
+export declare function useBasicFetch<T>(request: Request, options?: GetResponseOptions): Response<T>;
+export {};

package/dist/libs/common/src/react/flight/FlightMiddleware.d.ts

@@ -0,0 +1,11 @@
+import { Dispatch, Middleware, AnyAction } from 'redux';
+import { HashObject } from 'libs/common/react/interfaces/HashObject';
+import { ApplicationState } from 'libs/common/react/interfaces/ApplicationState';
+import { HttpRequest } from './interfaces';
+interface MiddlewareOptions {
+    fetchData: HttpRequest;
+    bootstrappedData?: HashObject;
+    defaultExpiryTime?: number;
+}
+export declare function createMiddleware(options: MiddlewareOptions): Middleware<HashObject, ApplicationState, Dispatch<AnyAction>>;
+export {};

package/dist/libs/common/src/react/flight/FlightReducer.d.ts

@@ -0,0 +1,2 @@
+import { FlightState, Action } from './interfaces';
+export declare function FlightReducer(state: FlightState, action: Action): FlightState;

package/dist/libs/common/src/react/flight/FlightSimulator.d.ts

@@ -0,0 +1,24 @@
+import { HashObject } from 'libs/common/react/interfaces/HashObject';
+/**
+ * This is a very basic implementation and we almost definitely will
+ * need to extend upon this, so please don't be afraid to add to it.
+ */
+export declare const Simulator: {
+    getAll(name: string, init?: HashObject[]): HashObject[];
+    get(name: string, id: string): HashObject;
+    create(name: string, item: HashObject): HashObject;
+    update(name: string, item: HashObject): HashObject;
+    delete(name: string, ids: string | string[]): void;
+    /**
+     *
+     * @param objectName - the name your object can be found under in local storage (e.g. `classrooms`).
+     * @param objectId - the id of the object you want to associate something to.
+     * @param assocName - the field name of your assoc, which will go on your object (e.g. `students`).
+     * @param flightSimName - the name your assoc objects will be created under (e.g. `school:students`).
+     * @param assocObject - the object you're creating and associating.
+     *
+     * Having a difficult time coming up with good param names here. Feel free to update, ty
+     */
+    assoc(objectName: string, objectId: string, assocName: string, flightSimName: string, assocObjects: any | any[]): any | any[];
+    dissoc(objectName: string, objectId: string, assocName: string, ids: string | string[]): HashObject[];
+};

package/dist/libs/common/src/react/flight/constants/Actions.d.ts

@@ -0,0 +1,7 @@
+export declare const Actions: {
+    API_REQUEST: string;
+    API_REPONSE: string;
+    API_ERROR: string;
+    INVALIDATE: string;
+    UPDATE: string;
+};

package/dist/libs/common/src/react/flight/constants/index.d.ts

@@ -0,0 +1 @@
+export * from './Actions';

package/dist/libs/common/src/react/flight/data-layers/AjaxRequest.d.ts

@@ -0,0 +1,2 @@
+import { HttpRequestOptions } from '../interfaces';
+export declare function ajaxRequest(options: HttpRequestOptions): void;

package/dist/libs/common/src/react/flight/data-layers/index.d.ts

@@ -0,0 +1 @@
+export * from './AjaxRequest';

package/dist/libs/common/src/react/flight/enums/RequestStatus.d.ts

@@ -0,0 +1,6 @@
+export declare enum RequestStatus {
+    None = "None",
+    Fetching = "Fetching",
+    Success = "Success",
+    Error = "Error"
+}

package/dist/libs/common/src/react/flight/enums/index.d.ts

@@ -0,0 +1 @@
+export * from './RequestStatus';

package/dist/libs/common/src/react/flight/index.d.ts

@@ -0,0 +1,9 @@
+export * from './constants';
+export * from './enums';
+export * from './interfaces';
+export * from './data-layers';
+export * from './normalizer';
+export * from './FlightHelpers';
+export * from './FlightMiddleware';
+export * from './FlightReducer';
+export * from './FlightSimulator';

package/dist/libs/common/src/react/flight/interfaces/Action.d.ts

@@ -0,0 +1,28 @@
+import { NormalizedEntities, Request, Normalized } from '..';
+import { Xhr } from 'libs/common/backbone/interfaces/Xhr';
+interface BaseAction {
+    type: string;
+    request: Request;
+}
+export interface RequestAction extends BaseAction {
+}
+interface BaseResponseAction extends BaseAction {
+    timestamp: number;
+    xhr?: Xhr;
+}
+export interface ResponseAction extends BaseResponseAction {
+    result: Normalized;
+    entities: NormalizedEntities;
+}
+export interface ErrorAction extends BaseResponseAction {
+    errorResponse?: any;
+}
+export interface InvalidateAction extends BaseAction {
+    keys?: string | string[];
+}
+export interface UpdateAction extends BaseAction {
+    result: Normalized;
+    entities: NormalizedEntities;
+}
+export declare type Action = RequestAction | ResponseAction | ErrorAction | InvalidateAction;
+export {};

package/dist/libs/common/src/react/flight/interfaces/Dispatch.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { RequestAction } from './Action';
+export declare type Dispatch = React.Dispatch<RequestAction>;

package/dist/libs/common/src/react/flight/interfaces/FlightState.d.ts

@@ -0,0 +1,22 @@
+import { RequestStatus } from '../enums';
+import { Request } from './Request';
+import { HashObject } from 'libs/common/react/interfaces/HashObject';
+export interface FlightState {
+    readonly entities: NormalizedEntities;
+    readonly resources: Resources;
+}
+export interface NormalizedEntities {
+    readonly [key: string]: HashObject;
+}
+export interface Resource {
+    readonly request: Request;
+    readonly status: RequestStatus;
+    readonly response?: string | string[] | HashObject | HashObject[];
+    readonly errorResponse?: any;
+    readonly timestamp?: number;
+    readonly statusCode?: number;
+    readonly entityIds?: string[];
+}
+export interface Resources {
+    readonly [key: string]: Resource;
+}

package/dist/libs/common/src/react/flight/interfaces/HttpRequest.d.ts

@@ -0,0 +1,27 @@
+import { HttpVerbs } from 'libs/common/backbone/enums/HttpVerbs';
+import { HashObject } from 'libs/common/react/interfaces/HashObject';
+import { Xhr } from 'libs/common/backbone/interfaces/Xhr';
+interface SuccessFunction {
+    (data: HashObject, xhr: Xhr): void;
+}
+interface ErrorFunction {
+    (xhr: Xhr): void;
+}
+interface AlwaysFunction {
+    (): void;
+}
+export interface HttpRequestOptions {
+    resource: string;
+    type: HttpVerbs;
+    data?: HashObject;
+    success: SuccessFunction;
+    error: ErrorFunction;
+    always?: AlwaysFunction;
+    headers?: {
+        authorization?: string;
+    };
+}
+export interface HttpRequest {
+    (options: HttpRequestOptions): void;
+}
+export {};

package/dist/libs/common/src/react/flight/interfaces/NormalizeOptions.d.ts

@@ -0,0 +1,4 @@
+export interface NormalizeOptions {
+    namespace?: string;
+    idAttribute?: string;
+}

package/dist/libs/common/src/react/flight/interfaces/NormalizedData.d.ts

@@ -0,0 +1,7 @@
+import { NormalizedEntities } from './FlightState';
+import { HashObject } from 'libs/common/react/interfaces/HashObject';
+export declare type Normalized = string | string[] | HashObject | HashObject[];
+export interface NormalizedData {
+    result: Normalized;
+    entities: NormalizedEntities;
+}

package/dist/libs/common/src/react/flight/interfaces/Request.d.ts

@@ -0,0 +1,29 @@
+import { HttpVerbs } from 'libs/common/backbone/enums/HttpVerbs';
+import { HashObject } from 'libs/common/react/interfaces/HashObject';
+import { Xhr, SimulatedXhr } from 'libs/common/backbone/interfaces/Xhr';
+import { NormalizeOptions } from './NormalizeOptions';
+import { Resources } from './FlightState';
+import { UpdateStateOptions } from './UpdateStateOptions';
+export interface Request {
+    key: string;
+    url: string;
+    type?: HttpVerbs;
+    expiryTime?: number;
+    data?: HashObject | HashObject[];
+    normalize?: boolean;
+    normalizeOptions?: NormalizeOptions;
+    formatData?: (data: HashObject | HashObject[]) => HashObject | HashObject[];
+    bootstrapName?: string;
+    invalidationKeys?: string | string[];
+    updateState?: UpdateStateOptions | UpdateStateOptions[];
+    success?: (data: HashObject | HashObject[] | number) => void;
+    error?: (Xhr: Xhr) => void;
+    always?: () => void;
+    maintainState?: (resources: Resources) => Resources;
+}
+export interface SimulatedRequest extends Request {
+    successResponse?: () => (HashObject | HashObject[]);
+    errorResponse?: () => SimulatedXhr;
+    timeout?: number;
+    noResponse?: boolean;
+}

package/dist/libs/common/src/react/flight/interfaces/Response.d.ts

@@ -0,0 +1,9 @@
+import { HttpStatus } from 'libs/common/backbone/enums/HttpStatus';
+export interface Response<T> {
+    data?: T;
+    statusCode?: HttpStatus;
+    shouldFetch: boolean;
+    isFetching: boolean;
+    hasError: boolean;
+    isComplete: boolean;
+}

package/dist/libs/common/src/react/flight/interfaces/UpdateStateOptions.d.ts

@@ -0,0 +1,15 @@
+import { HashObject } from 'libs/common/react/interfaces/HashObject';
+export interface UpdateStateOptions {
+    keys: string | string[];
+    /**
+     * updateData takes a hash where the keys are keys for resources
+     * from the application state that match the keys above.
+     * The value is the denormalized (where applicable) data corresponding
+     * to that resource.
+     */
+    updateData: (data: {
+        [key: string]: HashObject;
+    }) => {
+        [key: string]: HashObject;
+    };
+}

package/dist/libs/common/src/react/flight/interfaces/index.d.ts

@@ -0,0 +1,9 @@
+export * from './Request';
+export * from './Action';
+export * from './FlightState';
+export * from './HttpRequest';
+export * from './NormalizedData';
+export * from './Response';
+export * from './NormalizeOptions';
+export * from './Dispatch';
+export * from './UpdateStateOptions';

package/dist/libs/common/src/react/flight/normalizer/Denormalizer.d.ts

@@ -0,0 +1,3 @@
+import { HashObject } from 'libs/common/react/interfaces/HashObject';
+import { NormalizedEntities, Normalized } from '../interfaces';
+export declare function denormalize(ids: Normalized, collection: NormalizedEntities): HashObject | HashObject[];

package/dist/libs/common/src/react/flight/normalizer/Normalizer.d.ts

@@ -0,0 +1,8 @@
+import { HashObject } from 'libs/common/react/interfaces/HashObject';
+import { NormalizeOptions, NormalizedData } from '../interfaces';
+/**
+ * This is a pure function, while normalize() above is not.
+ * normalize() manipulates it's parameters. If we ever write unit tests for this
+ * only test this function, not the above ones.
+ */
+export declare function normalize(data: HashObject | HashObject[], options?: NormalizeOptions): NormalizedData;

package/dist/libs/common/src/react/flight/normalizer/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Normalizer';
+export * from './Denormalizer';

package/dist/libs/common/src/react/flight/utils/SimulatorHelper.d.ts

@@ -0,0 +1,5 @@
+import { Request, HttpRequestOptions } from '../interfaces';
+export declare const SimulatorHelper: {
+    isSimulated(request: Request): boolean;
+    simulateFetchData(options: HttpRequestOptions, request: Request): void;
+};

package/dist/libs/common/src/react/flight/utils/StateHelper.d.ts

@@ -0,0 +1,11 @@
+import { FlightState } from '../interfaces';
+export declare const StateHelper: {
+    /**
+     * Returns a map of keys state.resources which match the keys param.
+     *
+     * @param state FlightState.
+     * @param keys a key or array of keys to match on.
+     * @param requestKey optionally include the current request key to exclude it from the map.
+     */
+    getMatchingKeyMap(state: FlightState, keys: string | string[], requestKey?: string): any;
+};

package/dist/libs/common/src/react/flight/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './StateHelper';
+export * from './SimulatorHelper';

package/dist/libs/common/src/react/interfaces/ApplicationData.d.ts

@@ -0,0 +1,3 @@
+export interface ApplicationData {
+    version: string;
+}

package/dist/libs/common/src/react/interfaces/ApplicationState.d.ts

@@ -0,0 +1,8 @@
+import { ApplicationData } from 'libs/common/react/interfaces/ApplicationData';
+import { FlightState } from 'libs/common/react/flight/interfaces/FlightState';
+import { HashObject } from 'libs/common/react/interfaces/HashObject';
+export interface ApplicationState {
+    readonly flightData: FlightState;
+    readonly applicationData: ApplicationData;
+    readonly viewModelData: HashObject;
+}

package/dist/libs/common/src/react/interfaces/BaseReducerActions.d.ts

@@ -0,0 +1,4 @@
+export interface ReducerActions<TActionType, TPayloadType = any> {
+    type: TActionType;
+    payload?: TPayloadType;
+}

package/dist/libs/common/src/react/interfaces/HashObject.d.ts

@@ -0,0 +1,3 @@
+export interface HashObject<T = any> {
+    [key: string]: T;
+}

package/dist/libs/common/src/react/interfaces/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ApplicationData';
+export * from './ApplicationState';
+export * from './BaseReducerActions';
+export * from './HashObject';

package/dist/libs/common/src/react/utils/ArrayHelper.d.ts

@@ -0,0 +1,44 @@
+import * as _ from 'underscore';
+import { HashObject } from '../interfaces';
+declare type Iterator<T, TResult = T> = (value: T, index: number, list: T[]) => TResult;
+export declare const ArrayHelper: {
+    first<T>(arr: T[]): T;
+    firstFew<T_1>(arr: T_1[], count: number): T_1[];
+    last<T_2>(arr: T_2[]): T_2;
+    lastFew<T_3>(arr: T_3[], count: number): T_3[];
+    max<T_4, TResult = T_4>(arr: T_4[], iterator?: Iterator<T_4, TResult>): T_4;
+    cloneAndReplaceAtIdx<T_5>(arr: T_5[], idx: number, newVal: T_5, defaultValue?: any): T_5[];
+    moveItem<T_6>(arr: T_6[], fromIdx: number, toIdx: number): T_6[];
+    isEmpty<T_7>(arr: T_7[]): boolean;
+    findIndex<T_8>(arr: T_8[], predicate: (item: T_8) => boolean): number;
+    findWhere<T_9, U extends HashObject<any>>(arr: T_9[], properties: U): T_9;
+    where<T_10, U_1 extends HashObject<any>>(arr: T_10[], properties: U_1): T_10[];
+    groupBy<T_11>(arr: T_11[], property: string): {
+        [index: string]: T_11[];
+    };
+    flatten<T_12>(arr: T_12[], shallow?: boolean): T_12[];
+    intersection<T_13>(...arrays: T_13[][]): T_13[];
+    /**
+     * Add a value to an array, or if it is already in the array, remove it.
+     *
+     * @param arr array of values
+     * @param value value to be added or removed.
+     */
+    addOrRemove<T_14 = string | number>(arr: T_14[], value: T_14): T_14[];
+    /**
+     * This is the same addOrRemove function above, except it doesn't mutate the array in the argument
+     * and returns a branch new array.
+     */
+    addOrRemoveImmutable<T_15>(arr: T_15[], value: T_15): T_15[];
+    /**
+     * Returns a (stably) sorted copy of list, ranked in ascending order
+     * by the results of running each value through iteratee.
+     *
+     * @param arr array of values
+     * @param iteratee an iterator function or a string name of the property to sort by.
+     */
+    sortBy<T_16 extends HashObject<any>, TSort = T_16>(arr: T_16[], iteratee?: Iterator<T_16, TSort> | keyof T_16): T_16[];
+    chunk<T_17>(array: _.Collection<T_17>, count: number): T_17[][];
+    uniq<T_18 extends string | number | HashObject<any>, TSort_1 = T_18>(array: T_18[], iteratee?: Iterator<T_18, TSort_1> | keyof T_18): T_18[];
+};
+export {};

package/dist/libs/common/src/react/utils/ObjectHelper.d.ts

@@ -0,0 +1,11 @@
+export declare const ObjectHelper: {
+    isEmpty(obj: any): boolean;
+    values(obj: any): any[];
+    keys(obj: any): string[];
+    deepClone(obj: any): any;
+    getEnumKeys(obj: any): any[];
+    isObject(obj: any): boolean;
+    isEqual(obj1: any, obj2: any): boolean;
+    omit(obj: any, keys: string[]): any;
+    removeEmptyKeys(obj: any): any;
+};

package/dist/libs/common/src/react/utils/RandomHelper.d.ts

@@ -0,0 +1,3 @@
+export declare const RandomHelper: {
+    getRandomInt(max?: number): number;
+};

package/dist/libs/common/src/react/utils/TimeHelper.d.ts

@@ -0,0 +1,8 @@
+declare type TimeOfDay = 'morning' | 'afternoon' | 'evening';
+export declare const TimeHelper: {
+    currentTimestamp(): number;
+    isExpired(timestamp: number, cacheDuration: number): boolean;
+    currentTimeOfDay(currentTime?: Date): TimeOfDay;
+    convertDurationToSeconds(time: string): number;
+};
+export {};

package/dist/libs/shared/src/apps/notifications/enums/NotificationType.d.ts

@@ -0,0 +1,16 @@
+export declare enum NotificationType {
+    ExchangeVideoAvailable = "exchange-video-available",
+    WorkspaceVideoAvailable = "workspace-video-available",
+    Marketing = "marketing",
+    EditedVideoAvailable = "edited-video-available",
+    VideoRequestAvailable = "pay-tv-video-available",
+    VideoRequestDenied = "pay-tv-video-denied",
+    VideoReviewReminder = "term-update-review-reminder",
+    VideoReviewAddedToLibrary = "term-update-review-videos-added-to-library",
+    CustomLibraryVideoAvailable = "custom-library-video-available",
+    VideoProcessingFailed = "video-processing-failed",
+    StaffRequest = "new-staff-request",
+    StaffRequestFulfilled = "staff-request-fulfilment",
+    ChapterMergeSuccess = "media-concatenate-success",
+    SuggestEdit = "suggest-an-edit"
+}

package/dist/libs/shared/src/apps/upload/constants/UploadConstants.d.ts

@@ -0,0 +1,39 @@
+export declare const UploadEventNames: {
+    /**
+     * This is fired when a file has finished uploading to file API. This event
+     * has nothing to do with posting the uploaded resource to the respective repository.
+     */
+    UPLOAD_COMPLETE: string;
+    /**
+     * This is trigged when files are selected
+     * from either the FileSelectBehavior or the FileDropBehavior
+     */
+    FILES_SELECTED: string;
+    /**
+     * This triggered by the upload service when it received ingest urls for all
+     * the files added via a call to UploadService.addFiles(files: File[])
+     */
+    FILES_ADDED: string;
+    /**
+     * This is fired when the user cancels their own upload
+     */
+    UPLOAD_CANCELLED: string;
+    /**
+     * Name is self explanitory. This is only used internally by children
+     * of BasePendingItemsService at the moment
+     */
+    PENDING_ITEM_READY_TO_WATCH: string;
+    /**
+     * Fired when we know that the pending items in args has changed status
+     * or that it's foreground progress has been completed.
+     */
+    PENDING_ITEM_STATUS_CHANGE: string;
+    /**
+     * This is fired when the user cancels processing a recently uploaded video
+     */
+    PROCESSING_CANCELLED: string;
+    /**
+     * Fired when all uploads are finished or when uploading is cancelled. Unlocks navigation
+     */
+    UNLOCK_NAV: string;
+};