@clickview/library-editor 0.0.0-rc.0 → 0.0.1-rc.0

package/dist/src/shared/utils/ImageHelper.d.ts

@@ -0,0 +1,31 @@
+import { Thumbnail, Banner } from "../models";
+import { ImageType } from "../enums";
+declare type ImageSize = 'small' | 'medium' | 'large' | '';
+export interface ImageOptions {
+    size?: ImageSize;
+    bgColor?: string;
+    width?: number;
+    height?: number;
+    resizeType?: string;
+    ratio?: string;
+    name?: string;
+}
+export interface CategoryMapperImageOptions {
+    fallbackBaseUrl: string;
+    fallbackCategoryName: string;
+    type: ImageType;
+}
+export declare const ImageHelper: {
+    createUrl(baseUrl: string, options?: ImageOptions): string;
+    /**
+     * Ensures that strings are properly escaped before using them
+     * within a URL.
+     */
+    Rfc3986EncodeURIComponent(str: string): string;
+    createThumbnailUrl(thumbnail: string | Thumbnail, options?: ImageOptions): string;
+    createBannerUrl(banner: string | Banner, mappingOptions?: CategoryMapperImageOptions, imageOptions?: ImageOptions): string;
+    createFolderThumbnailUrl(thumbnail: string | Thumbnail, mappingOptions?: CategoryMapperImageOptions, imageOptions?: ImageOptions): string;
+    _createCategoryMappedUrl(mappingOptions: CategoryMapperImageOptions, options?: ImageOptions): string;
+    _createUrl(baseUrl: string, options?: ImageOptions): string;
+};
+export {};

package/dist/src/shared/utils/LazyLoadHelper.d.ts

@@ -0,0 +1,4 @@
+import { ObjectHash } from 'backbone';
+export declare const LazyLoadHelper: {
+    isLazyLoadSupported(minBrowserSupportVersion: ObjectHash): boolean;
+};

package/dist/src/shared/utils/LocalCacheHelper.d.ts

@@ -0,0 +1,7 @@
+import { LocalCacheDeviceCollection } from "../collections";
+import { LocalCacheDevice } from "../models";
+export declare const LocalCacheHelper: {
+    getDevicesUserCanManage(devices: LocalCacheDeviceCollection, customerId: string): LocalCacheDeviceCollection;
+    getNewestDeviceUserCanManage(devices: LocalCacheDeviceCollection, customerId: string): LocalCacheDevice;
+    customerHasLocalCache(devices: LocalCacheDeviceCollection, customerId: string): boolean;
+};

package/dist/src/shared/utils/MaskHelper.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="jquery" />
+/// <reference types="jqueryui" />
+/// <reference types="typeahead" />
+/// <reference types="bootstrap" />
+/// <reference types="dropzone" />
+export interface MaskHelperOptions {
+    targetSelector?: string;
+    additionalClasses?: string;
+    fade?: boolean;
+}
+export declare const MaskHelper: {
+    showMask(options?: MaskHelperOptions): JQuery<HTMLElement>;
+    hideMask(maskEl?: JQuery<HTMLElement>): void;
+    getTarget(targetSelector?: string): JQuery<HTMLElement>;
+};

package/dist/src/shared/utils/PartialLoadingHelper.d.ts

@@ -0,0 +1,6 @@
+import { Core } from '@clickview/common';
+declare type ViewContext = Core.View | Core.Component | Core.ComponentCollection;
+export declare const PartialLoadingHelper: {
+    renderPartialLoading(viewContext: ViewContext): any;
+};
+export {};

package/dist/src/shared/utils/PermissionsHelper.d.ts

@@ -0,0 +1,12 @@
+import { Core } from '@clickview/common';
+import { Video } from "../models";
+import { ObjectOwnerType } from "../../apps/library-editor/enums";
+export declare const PermissionsHelper: {
+    canEditVideo(video: Video): boolean;
+    canDownloadVideo(video: Video): boolean;
+    canAddToExchange(video: Video): boolean;
+    canShareVideo(video: Video, application: string): boolean;
+    getSuggestAnEditPermissionsMessage(video: Video): string;
+    getSharePermissionsMessage(video: Video, application: string): string;
+    filterObjectsByOwnerType(objects: Core.Collection<Core.Model>, owner: ObjectOwnerType, currentCustomerId?: string): Core.Collection<Core.Model>;
+};

package/dist/src/shared/utils/RadioChannelHelper.d.ts

@@ -0,0 +1,11 @@
+export declare const RadioChannelHelper: {
+    /**
+     * Used to generate a unique channel name for a view.
+     * If this.cid is undefined because the view has yet
+     * to be initialised (e.g. when using a behavior), then
+     * a customCid will be generated.
+     * @param self reference to the view
+     * @param customCidName the property name for the customCid
+     */
+    generateUniqueChannelName(self: any, customCidName?: string): string;
+};

package/dist/src/shared/utils/RatingHelper.d.ts

@@ -0,0 +1,6 @@
+import { ObjectHash } from 'backbone';
+import { Rating } from "../models";
+import { RatingCollection } from "../collections";
+export declare const RatingHelper: {
+    setRating(model: Rating, collection: RatingCollection, options?: ObjectHash): void;
+};

package/dist/src/shared/utils/RestrictedAccessHelper.d.ts

@@ -0,0 +1,13 @@
+import { Video } from "../models";
+import { YearGroup } from "../enums";
+declare const RestrictedAccessHelper: {
+    mapYearGroupToName(group: YearGroup): string;
+    hasRestriction(video: Video): boolean;
+    hasAdminRestriction(video: Video): boolean;
+    isAwaitingReview(video: Video): boolean;
+    getRestrictionMessage(name: string): string;
+    getReviewBadgeClassName(video: Video, baseClass: string, urgentClass: string): string;
+    getRestrictionTooltipMessage(video: Video): string;
+    getReviewTimeMessage(video: Video): string;
+};
+export { RestrictedAccessHelper };

package/dist/src/shared/utils/SettingsHelper.d.ts

@@ -0,0 +1,9 @@
+import { SettingKind } from "../enums";
+export interface SettingOptions {
+    kind: SettingKind;
+    name: string;
+    value: any;
+}
+export declare const SettingsHelper: {
+    getLibraryReviewOptions(value: boolean): SettingOptions;
+};

package/dist/src/shared/utils/SortHelper.d.ts

@@ -0,0 +1,15 @@
+import { Core } from '@clickview/common';
+import { SortType, ExportServiceSortType } from "../enums";
+import { ObjectHash } from 'backbone';
+declare const SortHelper: {
+    GetCurrentSortType(): SortType;
+    GetSortViewModel(): Core.Model;
+    GetFilterFromSort(sortType: SortType): string;
+    GetDefaultSort(): ObjectHash;
+    CreateSortObject(sortType: SortType): ObjectHash;
+    CreateSortCollection(): Core.Collection<Core.Model>;
+    GetSortName(sortType: SortType): string;
+    GetSortTypeFromName(sortName: string): SortType;
+    MapSortTypeToExportServiceSortType(sortType: SortType): ExportServiceSortType;
+};
+export { SortHelper };

package/dist/src/shared/utils/SpinnerHelper.d.ts

@@ -0,0 +1,19 @@
+export declare enum SpinnerSize {
+    Small = "sm",
+    Medium = "md",
+    Large = "lg"
+}
+export declare enum SpinnerType {
+    Standard = "std",
+    Light = "light",
+    LightBgDark = "light-bg-dark"
+}
+export interface SpinnerOptions {
+    size?: SpinnerSize;
+    type?: SpinnerType;
+    tag?: keyof HTMLElementTagNameMap;
+    extraClasses?: string;
+}
+export declare const SpinnerHelper: {
+    getSpinner(options?: SpinnerOptions): string;
+};

package/dist/src/shared/utils/SubtitleLanguageValidation.d.ts

@@ -0,0 +1,6 @@
+export declare const SubtitleLanguageValidation: {
+    name: {
+        required: boolean;
+        msg: () => string;
+    }[];
+};

package/dist/src/shared/utils/TabHelper.d.ts

@@ -0,0 +1,9 @@
+import { ObjectHash } from 'backbone';
+import { Core } from '@clickview/common';
+import { Tab } from "../components/tabs/TabsComponent";
+export declare const TabHelper: {
+    getEditVideoTabs(videoId: string, options?: ObjectHash): Tab[];
+    initBackButton(): void;
+    getBackButton(videoId: string): Tab;
+    getBackButtonText(appLink: Core.AppLink): string;
+};

package/dist/src/shared/utils/TextHelper.d.ts

@@ -0,0 +1,9 @@
+import { ObjectHash } from 'backbone';
+export declare const TextHelper: {
+    wordsHighlighter(text: string, words: string[]): string;
+    escapeExpression(text: string): string;
+    escapeRegExp(str: string): string;
+    slugify(str: string): string;
+    linkifyText(text: string, options?: ObjectHash): string;
+    extractKeyPhrases(text: string, keywords: string[], maxPhraseLength: number, maxNumPhrases?: number): string[];
+};

package/dist/src/shared/utils/TimeHelper.d.ts

@@ -0,0 +1,20 @@
+import { ObjectHash } from 'backbone';
+declare const TimeHelpers: {
+    /**
+     * Make time string into minutes if possible by trimming leading '0' and ':'
+     * E.g. 00:04:52 becomes -> 04:52
+     */
+    trimToMinutes(str: string): string;
+    toSeconds(timespan: string): number;
+    secondsToHoursFormatted(secs: number): string;
+    /**
+     * Extract hours/minutes/seconds components from a base time
+     */
+    getHoursComponent(secs: number): number;
+    getMinutesComponent(secs: number): number;
+    getSecondsComponent(secs: number): number;
+    millisecondsToSeconds(ms: number): number;
+    parseTime(timeObject: ObjectHash): number;
+    validateRawTime(timeObject: ObjectHash): ObjectHash;
+};
+export { TimeHelpers };

package/dist/src/shared/utils/VideoHelper.d.ts

@@ -0,0 +1,11 @@
+import { Video } from "../models";
+import { MasterObjectTypes } from "../enums";
+export declare const VideoHelper: {
+    hasLibraryOfType(video: Video, type: MasterObjectTypes): boolean;
+    hasCustomLibrary(video: Video): boolean;
+    /**
+     * Returns a comma seperated list of master types
+     */
+    getSourceTypes(video: Video): MasterObjectTypes[];
+    isExchangeVideo(video: Video): boolean;
+};

package/dist/src/shared/utils/handlebars/LangHelper.d.ts

@@ -0,0 +1,5 @@
+import * as Handlebars from 'handlebars';
+export declare const LangHelper: {
+    register(): void;
+    isValid(key: string, options: Handlebars.HelperOptions): boolean;
+};

package/dist/src/shared/utils/handlebars/index.d.ts

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

package/dist/src/shared/utils/index.d.ts

@@ -0,0 +1,27 @@
+export * from './DialogHelper';
+export * from './BulkCheckboxHelper';
+export * from './SortHelper';
+export * from './RestrictedAccessHelper';
+export * from './TimeHelper';
+export * from './SettingsHelper';
+export * from './FolderTreeHelpers';
+export * from './TextHelper';
+export * from './MaskHelper';
+export * from './PermissionsHelper';
+export * from './ImageHelper';
+export * from './RatingHelper';
+export * from './LocalCacheHelper';
+export * from './RadioChannelHelper';
+export * from './DurationHelper';
+export * from './FileExtensionsHelper';
+export * from './PartialLoadingHelper';
+export * from './SubtitleLanguageValidation';
+export * from './search';
+export * from './TabHelper';
+export * from './VideoHelper';
+export * from './CancelProcessingHelper';
+export * from './CollectionHelper';
+export * from './EmptyStateHelper';
+export * from './LazyLoadHelper';
+export * from './SpinnerHelper';
+export * from './handlebars';

package/dist/src/shared/utils/search/InstantSearchHelper.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="jquery" />
+import { ObjectHash } from 'backbone';
+import { RemoteSearch } from "./";
+/**
+ * Specific logic for processing responses from domain v1/search/instant endpoint
+ */
+export declare const InstantSearchHelper: {
+    prepareQuery: (query: string, settings: JQueryAjaxSettings, options?: ObjectHash) => string;
+    bloodhoundConfig(source: string, options: ObjectHash): RemoteSearch<any>;
+    handleResult(data: ObjectHash, item: any, options?: ObjectHash): any[];
+    processVideoResult(collection: any[], item: any, options: ObjectHash): any[];
+    processTagsResult(collection: any[], item: any, options: ObjectHash): any[];
+    processSeriesResult(collection: any[], item: any, options: ObjectHash): any[];
+    processFolderResult(collection: any[], item: any, options?: ObjectHash): any[];
+    /**
+     * Manipulate
+     * @param collection
+     * @param options
+     */
+    processCollection(collection: any[], options?: ObjectHash): any[];
+};

package/dist/src/shared/utils/search/RawSearchHelper.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="jquery" />
+import { ObjectHash } from 'backbone';
+import * as Search from "./";
+import { Tag, Producer, Distributor, Series, Channel } from "../../models";
+declare type RawSearchType = Producer | Distributor | Series | Channel | Tag;
+/**
+ * Specific logic for processing responses from domain instant/raw endpoint
+ */
+export declare const RawSearchHelper: {
+    handleQuery(dataSource?: Search.TypeaheadDataSource<RawSearchType>, options?: ObjectHash): Search.TypeaheadDataSource<RawSearchType>;
+    getSuggestionTemplate(sourceName: string): any;
+    getPendingTemplate(sourceName: string): any;
+    getNotFoundTemplate(sourceName: string, hideEmptyResults?: boolean): any;
+    getFooterTemplate(footerTemplate: Function): any;
+    prepareQuery: (query: string, settings: JQueryAjaxSettings, options?: ObjectHash) => string;
+    prepareUrl(source: string, options: ObjectHash): string;
+    mapRawSearchType(source: string, options: ObjectHash): string;
+    getBloodhoundConfig(): Search.BloodhoundConfigHandler<RawSearchType>;
+    getTypeaheadConfig(): any;
+};
+export {};

package/dist/src/shared/utils/search/RecentSearchHelper.d.ts

@@ -0,0 +1,12 @@
+import { StorageHelper } from '@clickview/common';
+export interface UpdateRecentSearchOptions<T> {
+    query: T;
+    add?: boolean;
+    remove?: boolean;
+    limit?: number;
+}
+export declare const RecentSearchHelper: {
+    getRecentSearches<T>(key: string, dataSource: StorageHelper): T[];
+    setRecentSearches<T_1>(key: string, recentSearches: T_1[], dataSource: StorageHelper): void;
+    updateRecentSearches<T_2>(key: string, dataSource: StorageHelper, options: UpdateRecentSearchOptions<T_2>): T_2[];
+};

package/dist/src/shared/utils/search/SearchTypes.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="typeahead" />
+import { ObjectHash } from 'backbone';
+import { Series, Folder, Video, Channel, Producer, Distributor } from "../../models";
+export declare type InstantSearch = Series | Folder | Video | Channel | Producer | Distributor;
+export interface RemoteSearch<T> extends Bloodhound.BloodhoundOptions<T> {
+    remote: Bloodhound.RemoteOptions<T>;
+}
+export interface LocalSearch<T> extends Bloodhound.BloodhoundOptions<T> {
+    local: T[] | (() => T[]);
+}
+export declare type TypeaheadDataSource<T> = Bloodhound<T> | ((query: string, syncResults: (result: T[]) => void, asyncResults?: (result: T[]) => void) => void);
+export interface InstantSearchBloodhound<T> {
+    bloodhound: TypeaheadDataSource<T>;
+    name: string;
+}
+export declare type TypeaheadConfig<T> = Twitter.Typeahead.Dataset<T>;
+export interface TypeaheadConfigHandler<T> {
+    (source?: InstantSearchBloodhound<T>, index?: number, options?: ObjectHash): Twitter.Typeahead.Dataset<T>;
+}
+export interface BloodhoundConfigHandler<T> {
+    (source: string, options?: ObjectHash): LocalSearch<T> | RemoteSearch<T>;
+}
+export interface TypeaheadSourceItem<T> {
+    name: string;
+    typeaheadConfig: TypeaheadConfigHandler<T>;
+    bloodhoundConfig?: BloodhoundConfigHandler<T>;
+    options?: ObjectHash;
+}

package/dist/src/shared/utils/search/TypeaheadHelper.d.ts

@@ -0,0 +1,76 @@
+/// <reference types="typeahead" />
+/// <reference types="jquery" />
+import { ObjectHash } from 'backbone';
+import * as Bloodhound from 'bloodhound';
+import { TypeaheadDataSource, LocalSearch, RemoteSearch, TypeaheadConfig } from "./";
+import { TypeaheadSourceItem } from "./SearchTypes";
+export declare const TypeaheadHelper: {
+    /**
+    * This function will only allow our typeahead to fetch results when we
+    * have exceeded our min length. The reason for doing this is that we want to the typeahead
+    * to load our recent searches immediately when we click the input, but before we perform any searches. - Mike
+    */
+    handleQuery<T>(dataSource?: TypeaheadDataSource<T>, options?: ObjectHash): TypeaheadDataSource<T>;
+    /**
+     * This function complements HandleQuery allowing us to override when and how typeahead templates are
+     * rendered. When the query doesn't meet our min length we will render a fallback template, which is
+     * essentially just an empty div. This is necessary to ensure we can display recent searchs when the
+     * typeahead is active (but less than the require length to trigger the search functionality). As we are
+     * dynamically generating the results for videos, folders and series we are deliberately using a closure
+     * to ensure we don't lose our template.
+     *
+     * It must also return <any> as the typeahead typings are shit.
+     * - Mike
+     */
+    getTemplate(template: Function, options?: ObjectHash): any;
+    /**
+     * Provides mechanism to map a single search query against multiple bloodhound sources.
+     * Sources may be remote endpoints or local in-memory collections.
+     * @param sources
+     * @param options
+     */
+    getSearchSources<T_1>(sources: TypeaheadSourceItem<T_1>[]): TypeaheadConfig<T_1>[];
+    /**
+     * Bloodhound helper
+     */
+    buildBloodhound<T_2>(options: RemoteSearch<T_2> | LocalSearch<T_2>): Bloodhound<T_2>;
+    /**
+     * This is attached as a callback to the typeahead's render event.
+     * Where there is a real suggestion from the server, we will automatically
+     * set the cursor to that item, to make it simply to add. This is to encourage the
+     * re-use of existing entities.
+     *
+     * Note: With multiple suggestion sets, the render event will also be called multiple times
+     * along with this callback.
+     */
+    selectFirstResult(e: JQueryEventObject, suggestions: any[], async: boolean, dataset: string): void;
+    /**
+    * Callback is designed to be attached to the stickit bindings for the typeahead form
+    * and emit events when a change is detected on the bound model. We do this to be
+    * able to detect whether an input has cleared from a previous selection,
+    *
+    * @param channelName
+    * @param event
+    */
+    emitEventOnInput(channelName: string, eventName: string, type: string, wrapperOptions?: ObjectHash): Function;
+    /**
+    * I hate this.
+    *
+    * Basically what this function does is curry a callback with the original association's
+    * data. Then, depending on the user's interaction with the typeahead input, it will restore that
+    * data when a blur event is triggered.
+    *
+    * @param data raw clone of original assoc model
+    *
+    * Curried callback
+    * @param channelName
+    * @param propertyName
+    */
+    resetAssociationOnBlur(data: ObjectHash): Function;
+    /**
+     * Create and render ConfirmSelection component for use as a
+     * @param options
+     */
+    getConfirmSelectionTemplate(options?: ObjectHash): Function;
+    clearInputOnBlur(channelName: string): void;
+};

package/dist/src/shared/utils/search/index.d.ts

@@ -0,0 +1,5 @@
+export * from './InstantSearchHelper';
+export * from './RecentSearchHelper';
+export * from './TypeaheadHelper';
+export * from './SearchTypes';
+export * from './RawSearchHelper';

package/dist/src/shared/utils/search/raw-search-components/add-new/AddNewSuggestion.d.ts

@@ -0,0 +1,12 @@
+import { ObjectHash } from 'backbone';
+/**
+ * Stateless component function
+ *
+ * Allows us to pass some simple data to a template along with
+ * optionally imported styling and/or svgs.
+ *
+ * The data and options are merged prior to being passed to the template.
+ *
+ * @param data
+ */
+export declare function AddNewSuggestion(data: ObjectHash): Function;

package/dist/src/shared/utils/search/raw-search-components/confirm-selection/ConfirmSelectionComponent.d.ts

@@ -0,0 +1,12 @@
+import { ObjectHash } from 'backbone';
+import { Core } from '@clickview/common';
+interface ConfirmSelectionComponentOptions extends Core.ComponentOptions {
+}
+export declare class ConfirmSelectionComponent extends Core.Component {
+    constructor(options: ConfirmSelectionComponentOptions);
+    get name(): string;
+    get template(): string;
+    get className(): string;
+    viewOptions(): ObjectHash;
+}
+export {};

package/dist/src/shared/utils/search/raw-search-components/index.d.ts

@@ -0,0 +1,2 @@
+export * from './confirm-selection/ConfirmSelectionComponent';
+export * from './add-new/AddNewSuggestion';

package/dist/src/shared/utils/search/raw-search-templates/index.d.ts

@@ -0,0 +1,5 @@
+import ResultSuggestion from './ResultSuggestion.hbs';
+import Loading from './Loading.hbs';
+import NotFound from './NotFound.hbs';
+import Empty from './Empty.hbs';
+export { ResultSuggestion, Loading, NotFound, Empty, };

package/dist/src/shared/views/download-to-local-cache/DownloadToLocalCacheView.d.ts

@@ -0,0 +1,28 @@
+import { ObjectHash } from 'backbone';
+import { Core } from '@clickview/common';
+import { LocalCacheDevice } from "../../models";
+interface DownloadToLocalCacheViewOptions extends Core.ViewOptions<LocalCacheDevice> {
+    videoId: string;
+}
+export declare class DownloadToLocalCacheView extends Core.View<LocalCacheDevice> {
+    options: DownloadToLocalCacheViewOptions;
+    private localCacheDataService;
+    private currentUser;
+    private localCacheDownloads;
+    private spinnerModel;
+    constructor(options: DownloadToLocalCacheViewOptions);
+    initialize(): void;
+    get name(): string;
+    get title(): string;
+    get lang(): string;
+    get template(): string;
+    get channelName(): string;
+    get behaviors(): any[];
+    private bindListeners;
+    private getSpinnerButtonOptions;
+    private onClickAddToLocalCache;
+    get requiredResources(): Core.RequiredResourceHash;
+    onBeforeRender(): boolean;
+    viewOptions(): ObjectHash;
+}
+export {};

package/dist/src/shared/views/download-video/DownloadVideoView.d.ts

@@ -0,0 +1,19 @@
+import { Core } from '@clickview/common';
+interface DownloadVideoViewOptions extends Core.ViewOptions {
+    videoId: string;
+}
+export declare class DownloadVideoView extends Core.View {
+    options: DownloadVideoViewOptions;
+    private downloadProxyDataService;
+    private config;
+    constructor(options: DownloadVideoViewOptions);
+    initialize(): void;
+    get name(): string;
+    get title(): boolean;
+    get tagName(): string;
+    get template(): string;
+    private cancelScrollTop;
+    get requiredResources(): Core.RequiredResourceHash;
+    onBeforeRender(): void;
+}
+export {};

package/dist/src/shared/views/index.d.ts

@@ -0,0 +1,9 @@
+export * from './download-video/DownloadVideoView';
+export * from './restrict-access/RestrictAccessView';
+export * from './share/ShareView';
+export * from './user-options/UserOptionsView';
+export * from './top-navigation/TopNavigationView';
+export * from './download-to-local-cache/DownloadToLocalCacheView';
+export * from './restrict-access/RestrictAccessComponent';
+export * from './restrict-access/RestrictAccessGroupComponent';
+export * from './restrict-access/RestrictAccessView';

package/dist/src/shared/views/restrict-access/RestrictAccessComponent.d.ts

@@ -0,0 +1,7 @@
+import { Core } from '@clickview/common';
+export declare class RestrictAccessComponent extends Core.Component {
+    get name(): string;
+    get template(): any;
+    get lang(): string;
+    private getTemplateText;
+}

package/dist/src/shared/views/restrict-access/RestrictAccessGroupComponent.d.ts

@@ -0,0 +1,23 @@
+import { ObjectHash } from 'backbone';
+import { Core } from '@clickview/common';
+export declare class RestrictAccessGroupComponent extends Core.Component {
+    private configDataService;
+    private currentUser;
+    private yearGroups;
+    initialize(): void;
+    get name(): string;
+    get lang(): string;
+    get props(): string[];
+    get template(): any;
+    /**
+     * Setup a binding for when the value of the year group changes
+     */
+    get bindings(): ObjectHash;
+    regions(): ObjectHash;
+    viewOptions(): ObjectHash;
+    onBeforeRender(): void;
+    onRender(): void;
+    onBeforeDestroy(): void;
+    private getYearGroups;
+    private buildGroupMessage;
+}

package/dist/src/shared/views/restrict-access/RestrictAccessView.d.ts

@@ -0,0 +1,67 @@
+import { ObjectHash } from 'backbone';
+import { Core } from '@clickview/common';
+import { Video } from "../../models";
+interface RestrictAccessViewOptions extends Core.ViewOptions {
+    videoId: string;
+}
+export declare class RestrictAccessView extends Core.View {
+    protected options: RestrictAccessViewOptions;
+    model: Video;
+    private config;
+    private selected;
+    private restriction;
+    private currentUser;
+    private videoDataService;
+    private restrictedVideoDataService;
+    private videoMixinService;
+    private restrictedObjectCollection;
+    private spinnerModel;
+    constructor(options: RestrictAccessViewOptions);
+    initialize(): void;
+    private bindListeners;
+    get name(): string;
+    get title(): string;
+    get lang(): string;
+    get tagName(): string;
+    get className(): string;
+    get channelName(): string;
+    get template(): any;
+    get behaviors(): any[];
+    get elements(): ObjectHash;
+    events(): ObjectHash;
+    regions(): ObjectHash;
+    private getAllowFullAccessBtnClassName;
+    private getSubmitBtnTooltipOptions;
+    /**
+     * Called when a dropdown access option is selected
+     */
+    private onOptionSelected;
+    /**
+     * Make sure a year group is selected in the year group button group
+     */
+    private onGroupChanged;
+    /**
+     * Returns corresponding view to render based on selected option
+     * and sets group if Students or All selected
+     */
+    private getAccessView;
+    /**
+     * Returns the dropdown item corresponding to the given restriction groupId
+     */
+    private getSelection;
+    /**
+     * Re-sets the server side restriction on the model, essentially refreshing the model with its
+     * actual restrictions. Also sets the dropdown selection to the dropdown corresponding to the restriction
+     */
+    private refreshRestriction;
+    private onSubmit;
+    private onAllowFullAccess;
+    private logAction;
+    private dataFetched;
+    private renderDropdown;
+    get requiredResources(): Core.RequiredResourceHash;
+    onBeforeRender(): void;
+    viewOptions(): ObjectHash;
+    onRender(): void;
+}
+export {};