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

package/dist/src/shared/services/PageVisibilityService.d.ts

@@ -0,0 +1,14 @@
+import { Core } from '@clickview/common';
+export declare class PageVisibilityService extends Core.Service {
+    private hiddenPropertyName;
+    private visibilityChangeEventName;
+    initialize(): void;
+    private detectVisibilityApi;
+    get name(): string;
+    get channelName(): string;
+    private bindEventListeners;
+    private onVisibilityChange;
+    addVisibilityChangeListener(callback: (hidden: boolean) => void): void;
+    removeVisibilityChangeListener(callback: (hidden: boolean) => void): void;
+    onDestroy(): void;
+}

package/dist/src/shared/services/PartialLoadingService.d.ts

@@ -0,0 +1,12 @@
+import { Core } from '@clickview/common';
+declare class PartialLoadingServiceStatic extends Core.Service {
+    get name(): string;
+    initialize(): void;
+    private renderPartialLoading;
+    private getComponent;
+    private getCtor;
+    getPartialLoadingRegions(self: any): any;
+    getCollection(length?: number): Core.Collection;
+}
+export declare const PartialLoadingService: PartialLoadingServiceStatic;
+export {};

package/dist/src/shared/services/RestrictedVideoDataService.d.ts

@@ -0,0 +1,14 @@
+import { BaseDataService } from '@clickview/common';
+import { VideoCollection, RestrictedObjectCollection } from "../collections";
+import { VideoCollectionIdentifier } from "../interfaces/VideoCollectionIdentifier";
+import { Cursors } from '@clickview/common';
+export declare class RestrictedVideoDataService extends BaseDataService {
+    get name(): string;
+    get channelName(): string;
+    get lang(): string;
+    getPaginationCursors(page: string): Cursors;
+    getRestrictedVideos(page?: string, callback?: (video: VideoCollection) => void): VideoCollection;
+    getVideoRestrictions(videoIds?: string[], collectionIdentifier?: VideoCollectionIdentifier, callback?: (restriction: RestrictedObjectCollection) => void): RestrictedObjectCollection;
+    updateVideoRestriction(videoId: string, groupId: string, customerId: string, userId: string, callback?: () => void): void;
+    deleteVideoRestriction(id: string, callback?: () => void): void;
+}

package/dist/src/shared/services/SettingsDataService.d.ts

@@ -0,0 +1,12 @@
+import { BaseDataService } from '@clickview/common';
+import { SettingOptions } from "../utils";
+import { SettingKind, SettingName } from "../enums";
+import { SettingCollection } from "../collections";
+import { Setting } from "../models";
+export declare class SettingsDataService extends BaseDataService {
+    get name(): string;
+    get channelName(): string;
+    getSetting(entityId: string, name: SettingName, callback?: (data: Setting) => void): Setting;
+    getSettings(entityId: string, kind?: SettingKind, callback?: (data: SettingCollection) => void): SettingCollection;
+    updateSetting(entityId: string, settingOptions: SettingOptions, successMessage?: string, callback?: (data: any) => void): void;
+}

package/dist/src/shared/services/UserDataService.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="backbone" />
+/// <reference types="backbone.radio" />
+/// <reference types="backbone.validation" />
+import { User } from "../models";
+import { BaseDataService } from '@clickview/common';
+import { DataServices } from "../constants/Services";
+export declare class UserDataService extends BaseDataService {
+    get name(): string;
+    get channelName(): string;
+    getCurrentUser(callback?: (user: User) => void): User;
+}
+declare const UserDataServiceHelper: {
+    currentUser: {
+        dataServiceName: DataServices;
+        eventName: string;
+        getData: (instance: UserDataService) => User;
+        getInstance: (context: import("backbone").Events) => unknown;
+        beforeOnBeforeRender: boolean;
+    };
+};
+export { UserDataServiceHelper };

package/dist/src/shared/services/VideoMixinService.d.ts

@@ -0,0 +1,17 @@
+import { Core } from '@clickview/common';
+import { VideoCollection, RestrictedObjectCollection, LocalCacheDownloadCollection } from "../collections";
+import { VideoCollectionIdentifier } from "../interfaces";
+import { Video } from "../models";
+export declare class VideoMixinService extends Core.Service {
+    private restrictedVideoDataService;
+    private localCacheDataService;
+    initialize(): void;
+    get name(): string;
+    get channelName(): string;
+    mixinVideoCollectionData(collection: VideoCollection, collectionIdentifier?: VideoCollectionIdentifier, callback?: (data: any) => void): void;
+    mixinVideoData(video: Video, callback?: (data: any) => void): void;
+    getAndMixinVideoCollectionRestrictions(collection: VideoCollection, collectionIdentifier?: VideoCollectionIdentifier, callback?: (data: any) => void): void;
+    getAndMixinVideoRestriction(video: Video, callback?: (data: any) => void): void;
+    mixinLocalCacheDownloads(video: Video, downloads: LocalCacheDownloadCollection): void;
+    mixinVideoRestriction(video: Video, restrictedObjectCollection: RestrictedObjectCollection): void;
+}

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

@@ -0,0 +1,18 @@
+export * from './AlertService';
+export * from './ConfigDataService';
+export * from './NavigationLockService';
+export * from './UserDataService';
+export * from './PartialLoadingService';
+export * from './SettingsDataService';
+export * from './CustomerDataService';
+export * from './LocalCacheDataService';
+export * from './VideoMixinService';
+export * from './RestrictedVideoDataService';
+export * from './PageVisibilityService';
+export * from './PageTitleService';
+export * from './ContextService';
+export * from './LanguageService';
+export * from './LanguageDataService';
+export * from './ContextService';
+export * from './DownloadProxyDataServices';
+export * from './IntercomService';

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

@@ -0,0 +1,18 @@
+import { Core } from '@clickview/common';
+interface GetSelectedRequest {
+    key: string;
+    type: string;
+    collection: Core.Collection;
+    excludePredicate?: (model: Core.Model) => boolean;
+}
+declare const BulkCheckboxHelper: {
+    /**
+     * We store the bulk actions view model until we've moved to another
+     * collection id. This is so that page changes like Move/Delete video
+     * doesnt clear the checkboxes but moving to another folder does.
+     */
+    GetViewModel(key: string, type: string): Core.Model;
+    GetSelectedIds(options: GetSelectedRequest): string[];
+    GetSelectedModels(options: GetSelectedRequest): Core.Model[];
+};
+export { BulkCheckboxHelper };

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

@@ -0,0 +1,4 @@
+import { Core } from '@clickview/common';
+export declare const CancelProcessingHelper: {
+    generateDialog(videoTitle: string, channelName: string, eventName: string, videoItem: Core.Model): void;
+};

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

@@ -0,0 +1,10 @@
+import { ObjectHash } from 'backbone';
+import { Core } from '@clickview/common';
+declare const CollectionHelpers: {
+    setSelected(modelId: string, collection: Core.Collection<Core.Model>): void;
+    getSelected<TCollection extends Core.Collection<Core.Model>>(collection: TCollection): Core.Model;
+    deselectAll<TCollection_1 extends Core.Collection<Core.Model>>(collection: TCollection_1, options?: ObjectHash): void;
+    findModelByName<TModel extends Core.Model, TCollection_2 extends Core.Collection<TModel>>(name: string, collection: TCollection_2): TModel;
+    getIds<TCollection_3 extends Core.Collection<Core.Model>>(collection: TCollection_3): number[];
+};
+export { CollectionHelpers };

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

@@ -0,0 +1,9 @@
+/// <reference types="jquery" />
+import { Core } from '@clickview/common';
+import { DialogViewOptions } from "../components";
+export declare class DialogHelper extends Core.Service {
+    private dialogOptions;
+    constructor(options: DialogViewOptions);
+    get name(): string;
+    render(): JQueryDeferred<any>;
+}

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

@@ -0,0 +1,7 @@
+declare const DurationHelper: {
+    /**
+     * Copypasta from Online. Feel free to improve it if you see fit - Sha
+     */
+    ToDisplayDuration(milliseconds: number): string;
+};
+export { DurationHelper };

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

@@ -0,0 +1,4 @@
+import { Core } from '@clickview/common';
+export declare const EmptyStateHelper: {
+    isCollectionEmpty(view: Core.View<Core.Model>, collectionName?: string): boolean;
+};

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

@@ -0,0 +1,9 @@
+declare const FileExtensions: {
+    IMAGES: string;
+    RESOURCES: string;
+    SUBTITLES: string;
+};
+declare const FileExtensionHelper: {
+    getResourceType(extension: string): string;
+};
+export { FileExtensions, FileExtensionHelper };

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

@@ -0,0 +1,36 @@
+import { Core } from '@clickview/common';
+import { FolderCollection } from "../collections";
+import { Folder } from "../models";
+declare const FolderTreeHelpers: {
+    isSelected(key: string, id?: string): boolean;
+    isParent(key: string, id: string): boolean;
+    getSelectedViewModel(key: string): Core.Model;
+    deselectAll(key: string, collection: FolderCollection): void;
+    /**
+     * Sets a folder in a collection as selected
+     * @param folder either the folder model or the id of the folder
+     * @param collection the folder collection
+     */
+    setSelected(key: string, folder: string | Folder, collection: FolderCollection): void;
+    getSelected(key: string, collection: FolderCollection): Folder;
+    newFolder(): Folder;
+    getModelFromCollection(id: string, collection: FolderCollection): Folder;
+    getParent(id: string, collection: FolderCollection): Folder;
+    addFolder(model: Core.Model, parentId: string, collection: FolderCollection): void;
+    addFolderToLibrary(model: Core.Model, collectionId: string, collection: FolderCollection): void;
+    /**
+     * This will flatten the nested folder structure and provide
+     * a depth value for each folder. This is designed to be used
+     * by the FolderSelectView but can be used by anything that needs
+     * the folders flattened.
+     */
+    flatten(collection: FolderCollection): FolderCollection;
+    getFirstType(collection: FolderCollection, type: string): Folder;
+    getLibrary(folderId: string, collection: FolderCollection): Folder;
+    isSubFolder(folder: Folder): boolean;
+    getFolderDepth(id: string, collection: FolderCollection): number;
+    getFolderChord(folder: Folder): string;
+    getDepthOfChildren(folder: Folder): number;
+    calculateDestinationFolderDepth(folder: Folder, destinationId: string, collection: FolderCollection): number;
+};
+export { FolderTreeHelpers };

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