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

package/dist/src/shared/components/image-cropper/ImageCropperComponent.d.ts

@@ -0,0 +1,34 @@
+import { ObjectHash } from 'backbone';
+import { Core } from '@clickview/common';
+import { Image } from "../../models";
+import { ImageType } from "../../enums";
+export declare enum CropEventNames {
+    ClickCrop = "click:crop",
+    CropImage = "crop:image",
+    ImageCropped = "image:cropped"
+}
+export interface ImageCropperComponentOptions extends Core.ComponentOptions {
+    channelName: string;
+    imageType: ImageType;
+    minHeight: number;
+    minWidth: number;
+    getCropRegionWidth: Function;
+}
+export declare class ImageCropperComponent extends Core.Component<Image> {
+    options: ImageCropperComponentOptions;
+    private cropper;
+    constructor(options: ImageCropperComponentOptions);
+    initialize(): void;
+    get name(): string;
+    get template(): string;
+    get className(): string;
+    get elements(): ObjectHash;
+    private getMinCropBoxWidth;
+    private getMinCropBoxHeight;
+    private getViewportToImageRatio;
+    private crop;
+    private getImageMimeType;
+    private renderCropper;
+    onRender(): void;
+    onBeforeDestroy(): void;
+}

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

@@ -0,0 +1,46 @@
+export * from './alert/AlertComponentCollection';
+export * from './top-navigation/TopNavigationComponentCollection';
+export * from './edit-video/edit-basic-info/EditBasicInfoComponent';
+export * from './edit-video/edit-production-info/EditProductionInfoComponent';
+export * from './edit-video/select-rating/SelectRatingCollectionComponent';
+export * from './edit-video/select-rating/SelectRatingComponent';
+export * from './edit-video/edit-additional-info/EditAdditionalInfoComponent';
+export * from './edit-video/edit-broadcast/EditBroadcastComponent';
+export * from './edit-video/edit-broadcast/ToggleBroadcastComponent';
+export * from './edit-video/extra-info/ExtraInfoComponent';
+export * from './edit-video/extra-info/ExtraInfoItemComponent';
+export * from './typeahead-input/SearchTypeaheadComponent';
+export * from './bulk-video-actions/BulkVideoActionsComponent';
+export * from './checkbox/CheckboxComponent';
+export * from './checkbox/BulkCheckboxComponent';
+export * from './left-nav/LeftNavComponent';
+export * from './page-footer/PageFooterComponent';
+export * from './pagination/PaginationComponent';
+export * from './video-basic-info/VideoBasicInfoComponent';
+export * from './video-item-preview/VideoItemPreviewComponent';
+export * from './video-preview/VideoPreviewComponent';
+export * from './page-header/PageHeaderComponent';
+export * from './thumbnail/ThumbnailComponent';
+export * from './video-item';
+export * from './video-description/VideoDescriptionComponent';
+export * from './video-list/VideoListComponent';
+export * from './video-actions/VideoActionsComponent';
+export * from './image-cropper/ImageCropperComponent';
+export * from './clear-button/ClearButtonComponent';
+export * from './breadcrumbs/BreadcrumbsComponent';
+export * from './alert/AlertItemComponent';
+export * from './alert/AlertComponentCollection';
+export * from './web-player/WebPlayerComponent';
+export * from './select/SelectComponent';
+export * from './partial-loading';
+export * from './typeahead-list/TypeaheadListComponent';
+export * from './fields/FieldsComponent';
+export * from './video-description/VideoDescriptionComponent';
+export * from './edit-video/edit-season-info/EditSeasonInfoComponent';
+export * from './resizing-text-area/ResizingTextAreaComponent';
+export * from './dialog/DialogView';
+export * from './dropdown/DropdownButtonComponent';
+export * from './dropdown/DropdownComponentCollection';
+export * from './dropdown/DropdownItemComponent';
+export * from './empty-state/EmptyStateComponent';
+export * from './spinner-button/SpinnerButtonComponent';

package/dist/src/shared/components/left-nav/LeftNavComponent.d.ts

@@ -0,0 +1,27 @@
+import { ObjectHash } from 'backbone';
+import { Core } from '@clickview/common';
+import { AnalyticsOptions } from '@clickview/analytics';
+export interface LeftNavComponentOptions extends Core.ComponentOptions {
+    styles?: any;
+    channelName: string;
+    childrenProperty?: string;
+    textProperty?: string;
+    appLink: Core.AppLink;
+    linkArgs?: (model: Core.Model) => any[];
+    linkParams?: (model: Core.Model) => string | ObjectHash;
+    actions?: new (...args: any[]) => Core.Component;
+    extraClasses?: string;
+    extraClass?: string;
+    folderTreeId: string;
+    analyticsOptions?: AnalyticsOptions;
+}
+export declare class LeftNavComponent extends Core.ComponentCollection {
+    protected options: LeftNavComponentOptions;
+    constructor(options?: LeftNavComponentOptions);
+    get name(): string;
+    get tagName(): string;
+    get childView(): any;
+    get className(): string;
+    get viewComparator(): string;
+    get childViewOptions(): LeftNavComponentOptions;
+}

package/dist/src/shared/components/left-nav/LeftNavNodeComponent.d.ts

@@ -0,0 +1,47 @@
+/// <reference types="jquery" />
+import { ObjectHash } from 'backbone';
+import { Core } from '@clickview/common';
+import { LeftNavComponentOptions } from "..";
+export declare class LeftNavNodeComponent extends Core.Component {
+    options: LeftNavComponentOptions;
+    /**
+     * This is used to not re-render the sub children during drag and drop
+     */
+    private renderedSubChildren;
+    constructor(options?: LeftNavComponentOptions);
+    initialize(): void;
+    get name(): string;
+    get elements(): ObjectHash;
+    get tagName(): string;
+    get className(): string;
+    get behaviors(): any[];
+    get appLinks(): Core.AppLinkHash;
+    events(): ObjectHash;
+    regions(): ObjectHash;
+    get template(): any;
+    hasChildren(): boolean;
+    getChildren(): Core.Collection;
+    getText(): string;
+    private isSelected;
+    private isParent;
+    private getAnchorClass;
+    private getAppLink;
+    /**
+     * Clicking on a folder can result in one of three outcomes, depending on the
+     * current state of the folder and the user's intent;
+     *
+     * 1. Where the folder isn't selected, navigate to that folder, select it and open any children.
+     * 2. Where the folder is already selected and we *aren't* already on the target route,
+     *    navigate to the target route.
+     * 3. Where the folder is already selected and we *are* on the same route as the target route,
+     *    we will only toggle the open/closed state of any children (no route change will occur).
+     */
+    onClick(event: JQuery.Event): void;
+    private isCurrentPath;
+    private closeChildren;
+    private openChildren;
+    private onOpenSubFolders;
+    private renderChildren;
+    viewOptions(): ObjectHash;
+    onRender(): void;
+}

package/dist/src/shared/components/page-footer/PageFooterComponent.d.ts

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

package/dist/src/shared/components/page-header/PageHeaderComponent.d.ts

@@ -0,0 +1,25 @@
+import { ObjectHash } from 'backbone';
+import { Core } from '@clickview/common';
+interface PageHeaderComponentOptions extends Core.ComponentOptions {
+    onlyShowProfile?: boolean;
+}
+export declare class PageHeaderComponent extends Core.Component {
+    protected options: PageHeaderComponentOptions;
+    constructor(options?: PageHeaderComponentOptions);
+    get name(): string;
+    get template(): any;
+    get tagName(): string;
+    get className(): string;
+    regions(): ObjectHash;
+    events(): ObjectHash;
+    private onClick;
+    private logAction;
+    private getSearchModel;
+    private renderSearchBar;
+    private renderUpload;
+    private renderNotificationsStatus;
+    private renderUserDropdown;
+    viewOptions(): ObjectHash;
+    onRender(): void;
+}
+export {};

package/dist/src/shared/components/pagination/PaginationComponent.d.ts

@@ -0,0 +1,28 @@
+import { ObjectHash } from 'backbone';
+import { Core, Cursors } from '@clickview/common';
+import { AnalyticsOptions } from '@clickview/analytics';
+interface PaginationComponentOptions extends Core.ComponentOptions {
+    cursors: Cursors;
+    appLink: Core.AppLink;
+    collectionId?: string;
+    allowFirstPageCursor?: boolean;
+    analyticsOptions?: AnalyticsOptions;
+    cursorParamName?: string;
+}
+export declare class PaginationComponent extends Core.Component {
+    options: PaginationComponentOptions;
+    constructor(options: PaginationComponentOptions);
+    get defaults(): ObjectHash;
+    get name(): string;
+    get template(): any;
+    get lang(): string;
+    get appLinks(): Core.AppLinkHash;
+    events(): ObjectHash;
+    private buildCursor;
+    private onClickPrevious;
+    private onClickNext;
+    private logAction;
+    viewOptions(): ObjectHash;
+    onBeforeRender(): boolean;
+}
+export {};

package/dist/src/shared/components/partial-loading/PartialLoadingComponent.d.ts

@@ -0,0 +1,16 @@
+import { ObjectHash } from 'backbone';
+import { Core } from '@clickview/common';
+export interface PartialLoadingComponentOptions extends Core.ComponentOptions {
+    template: string;
+    tagName?: keyof HTMLElementTagNameMap;
+    className?: string;
+    viewOptions?: ObjectHash;
+}
+export declare class PartialLoadingComponent extends Core.Component {
+    protected options: PartialLoadingComponentOptions;
+    constructor(options?: PartialLoadingComponentOptions);
+    get name(): string;
+    get tagName(): string;
+    get className(): string;
+    viewOptions(): ObjectHash;
+}

package/dist/src/shared/components/partial-loading/PartialLoadingComponentCollection.d.ts

@@ -0,0 +1,20 @@
+import { Core } from '@clickview/common';
+import { PartialLoadingComponent, PartialLoadingComponentOptions } from "./PartialLoadingComponent";
+interface PartialLoadingComponentCollectionOptions extends Core.ComponentCollectionOptions {
+    tagName?: keyof HTMLElementTagNameMap;
+    className?: string;
+    noExtraClass?: boolean;
+    collectionLength?: number;
+    childOptions: PartialLoadingComponentOptions;
+}
+export declare class PartialLoadingComponentCollection extends Core.ComponentCollection {
+    options: PartialLoadingComponentCollectionOptions;
+    constructor(options?: PartialLoadingComponentCollectionOptions);
+    initialize(): void;
+    get name(): string;
+    get tagName(): string;
+    get className(): string;
+    get childView(): typeof PartialLoadingComponent;
+    get childViewOptions(): PartialLoadingComponentOptions;
+}
+export {};

package/dist/src/shared/components/partial-loading/index.d.ts

@@ -0,0 +1,2 @@
+export * from './PartialLoadingComponent';
+export * from './PartialLoadingComponentCollection';

package/dist/src/shared/components/resizing-text-area/ResizingTextAreaComponent.d.ts

@@ -0,0 +1,23 @@
+import { Core } from '@clickview/common';
+interface ResizingTextAreaComponentOptions extends Core.ComponentOptions {
+    name?: string;
+    id?: string;
+    class?: string;
+    placeholder?: string;
+    required?: boolean;
+    readonly?: boolean;
+    disabled?: boolean;
+}
+export declare class ResizingTextAreaComponent extends Core.Component {
+    options: ResizingTextAreaComponentOptions;
+    constructor(options: ResizingTextAreaComponentOptions);
+    get name(): string;
+    get template(): string;
+    events(): any;
+    /**
+     * https://gomakethings.com/automatically-expand-a-textarea-as-the-user-types-using-vanilla-javascript/
+     */
+    private onInput;
+    viewOptions(): ResizingTextAreaComponentOptions;
+}
+export {};

package/dist/src/shared/components/select/SelectComponent.d.ts

@@ -0,0 +1,54 @@
+import { ObjectHash } from 'backbone';
+import { Core } from '@clickview/common';
+import { DropdownAnalyticsHelper } from "..";
+export interface SelectChildOptions {
+    channelName?: string;
+    titleProperty?: string;
+    eventName: string;
+    extraClasses?: string;
+    prefixHandler?: () => string;
+    currentSelectedMessage?: string;
+    isDisabled?: (model: Core.Model) => boolean;
+    truncateOptionNames?: boolean;
+}
+export interface SelectComponentOptions extends Core.ComponentCollectionOptions {
+    channelName: string;
+    childOptions: SelectChildOptions;
+    placeholderText: string;
+    noOptionsText?: string;
+    inputName?: string;
+    disabled?: boolean;
+    displayProperty?: string;
+    analyticsHelper: DropdownAnalyticsHelper;
+}
+export declare class SelectComponent extends Core.Component {
+    collection: Core.Collection;
+    options: SelectComponentOptions;
+    private selectSearch;
+    private sameCharIndex;
+    private scopedTimerIndex;
+    private optionStep;
+    constructor(options: SelectComponentOptions);
+    initialize(): void;
+    get name(): string;
+    get template(): any;
+    regions(): ObjectHash;
+    events(): ObjectHash;
+    get defaults(): ObjectHash;
+    get elements(): ObjectHash;
+    private bindListeners;
+    private onShowDropdown;
+    private onKeydown;
+    private onArrowKeyDown;
+    private onType;
+    onSelect(model: Core.Model): void;
+    setModel(): void;
+    private getNextModel;
+    private getModelMatch;
+    private handleSameCharIndex;
+    private runTimer;
+    private isDisabled;
+    private getButtonText;
+    viewOptions(): ObjectHash;
+    onRender(): void;
+}

package/dist/src/shared/components/spinner-button/SpinnerButtonComponent.d.ts

@@ -0,0 +1,73 @@
+import { ObjectHash } from 'backbone';
+import { Core } from '@clickview/common';
+import { TooltipOptions } from "../../interfaces";
+import { SpinnerOptions } from "../../utils";
+export declare const SpinnerButtonEvents: {
+    ShowSpinner: string;
+    HideSpinner: string;
+    ToggleSpinner: string;
+    Enable: string;
+    Disable: string;
+    ManageDimensions: string;
+};
+export declare const SpinnerButtonModelAttributes: {
+    ShowSpinner: string;
+    Disabled: string;
+};
+export interface SpinnerButtonComponentOptions extends Core.ViewOptions {
+    saveEvent: string;
+    channelName?: string;
+    showSpinner?: boolean;
+    extraButtonClass?: string;
+    buttonText?: string | Function;
+    buttonType?: 'submit' | 'reset' | 'button';
+    detectWidth?: boolean;
+    detectHeight?: true;
+    preventMultiClick?: boolean;
+    tooltip?: TooltipOptions | (() => TooltipOptions);
+    spinnerOptions?: SpinnerOptions;
+    disabled?: boolean;
+}
+export declare class SpinnerButtonComponent extends Core.Component {
+    protected options: SpinnerButtonComponentOptions;
+    constructor(options?: SpinnerButtonComponentOptions);
+    get name(): string;
+    get tagName(): string;
+    /**
+     * TODO: Use the Tooltip behaviour once we allow it to be toggleable within
+     * the behaviour itself.
+     */
+    get attributes(): ObjectHash;
+    get template(): any;
+    get className(): string;
+    events(): ObjectHash;
+    get defaults(): ObjectHash;
+    initialize(): void;
+    private bindSpinnerListeners;
+    private bindDisableListeners;
+    private getButtonText;
+    private getTooltipOptions;
+    private onClick;
+    private toggleSpinner;
+    private showSpinner;
+    private hideSpinner;
+    private enableButton;
+    private disableButton;
+    private manageDimensions;
+    /**
+     * Store current dimensions of button
+     * This will only execute after an initial render event as it's triggered in the
+     * onBeforeRender handler.
+     */
+    private storeDimensions;
+    /**
+     * Apply the stored dimention state
+     * Only applied if we already have stored some dimensions
+     */
+    private applyDimensions;
+    private renderTooltip;
+    viewOptions(): ObjectHash;
+    onAttach(): void;
+    onRender(): void;
+    onBeforeDestroy(): void;
+}

package/dist/src/shared/components/tabs/TabsComponent.d.ts

@@ -0,0 +1,28 @@
+import { ObjectHash } from 'backbone';
+import { Core } from '@clickview/common';
+interface TabAppLink {
+    selector: string;
+    appLink: Object;
+}
+export interface Tab {
+    name: string | (() => string);
+    active?: boolean;
+    link: TabAppLink;
+    hide?: boolean;
+}
+interface TabsComponentOptions extends Core.ComponentOptions {
+    tabs: Array<Tab>;
+    activeTab: string;
+}
+export declare class TabsComponent extends Core.Component {
+    options: TabsComponentOptions;
+    constructor(options: TabsComponentOptions);
+    get name(): string;
+    get className(): string;
+    get template(): any;
+    get appLinks(): ObjectHash;
+    viewOptions(): ObjectHash;
+    private setActiveTab;
+    onBeforeRender(): void;
+}
+export {};

package/dist/src/shared/components/thumbnail/ThumbnailComponent.d.ts

@@ -0,0 +1,32 @@
+import { ObjectHash } from 'backbone';
+import { Core } from '@clickview/common';
+import { Video } from "../../models";
+import { ImageOptions } from "../../utils";
+export interface ThumbnailComponentOptions extends Core.ComponentOptions {
+    model: Video;
+    onClickHandler?: Function;
+    thumbnailOptions?: ImageOptions;
+    playIcon?: boolean;
+    lazyload?: boolean;
+    appLink?: Core.AppLink;
+    href?: string;
+    channelName?: string;
+}
+export declare class ThumbnailComponent extends Core.Component<Video> {
+    protected options: ThumbnailComponentOptions;
+    constructor(options: ThumbnailComponentOptions);
+    initialize(): void;
+    get name(): string;
+    get template(): string;
+    get tagName(): string;
+    get className(): string;
+    get elements(): ObjectHash;
+    events(): ObjectHash;
+    get appLinks(): Core.AppLinkHash;
+    get attributes(): ObjectHash;
+    private showPlayIcon;
+    private onClick;
+    private onImageLoad;
+    viewOptions(): ObjectHash;
+    onRender(): void;
+}

package/dist/src/shared/components/top-navigation/TopNavigationComponentCollection.d.ts

@@ -0,0 +1,29 @@
+import { ObjectHash } from 'backbone';
+import { Core } from '@clickview/common';
+interface TopNavigationItemComponentOptions extends Core.ComponentOptions {
+    selected: Core.AppLink;
+}
+declare class TopNavigationItemComponent extends Core.Component {
+    options: TopNavigationItemComponentOptions;
+    constructor(options: TopNavigationItemComponentOptions);
+    get name(): string;
+    get tagName(): string;
+    get className(): string;
+    private isSelected;
+    get appLinks(): Core.AppLinkHash;
+    get template(): any;
+    private getCount;
+    viewOptions(): ObjectHash;
+}
+interface TopNavigationComponentCollectionOptions extends Core.ComponentCollectionOptions {
+    selected?: Core.AppLink;
+}
+export declare class TopNavigationComponentCollection extends Core.ComponentCollection {
+    options: TopNavigationComponentCollectionOptions;
+    constructor(options?: TopNavigationComponentCollectionOptions);
+    get name(): string;
+    get className(): string;
+    get childView(): typeof TopNavigationItemComponent;
+    get childViewOptions(): TopNavigationItemComponentOptions;
+}
+export {};

package/dist/src/shared/components/typeahead-input/SearchTypeaheadComponent.d.ts

@@ -0,0 +1,74 @@
+/// <reference types="typeahead" />
+import { Core } from '@clickview/common';
+import { ObjectHash } from 'backbone';
+import { TypeaheadConfigHandler, TypeaheadSourceItem } from "../../utils/search";
+interface TypeaheadCallbacks {
+    onRender?: Function;
+    onInput?: Function;
+    onBlur?: Function;
+}
+interface TypeaheadActionOptions {
+    clearOnSelect?: boolean;
+}
+interface SearchTypeaheadComponentOptions<TSearchType> extends Core.ComponentOptions {
+    parentChannelName: string;
+    inputId: string;
+    selectEvent: string;
+    typeaheadConfigs: TypeaheadSourceItem<TSearchType> | TypeaheadSourceItem<TSearchType>[];
+    stickItProperty?: string;
+    inputName?: string;
+    placeholderText?: string;
+    callbacks?: TypeaheadCallbacks;
+    typeaheadOptions?: ObjectHash;
+    actionOptions?: TypeaheadActionOptions;
+    editable?: boolean;
+    additionalClasses?: string;
+    removeEvent?: string;
+    forceShowRemoveButton?: boolean;
+}
+export declare class SearchTypeaheadComponent<TSearchType> extends Core.Component {
+    options: SearchTypeaheadComponentOptions<TSearchType>;
+    private parentChannel;
+    constructor(options?: SearchTypeaheadComponentOptions<TSearchType>);
+    get name(): string;
+    get template(): any;
+    get className(): string;
+    get channelName(): string;
+    get elements(): ObjectHash;
+    get defaults(): ObjectHash;
+    events(): ObjectHash;
+    initialize(): void;
+    protected bindListeners(): void;
+    get bindings(): ObjectHash;
+    clearInput(): void;
+    setInput(newVal: string): void;
+    /**
+     * TODO: Add submit on enter support
+     */
+    protected onTypeaheadSelect(event: any, suggestion: string | ObjectHash, source: any): void;
+    private onSubmit;
+    private onClickRemove;
+    protected getSources(): TypeaheadConfigHandler<TSearchType>[] | Twitter.Typeahead.Dataset<TSearchType>[];
+    private getTypeaheadOptions;
+    private getTypeaheadActionOptions;
+    private bindOptionalCallbacks;
+    protected initTypeahead(): void;
+    protected initTypeaheadListeners(): void;
+    private toggleRemove;
+    /**
+     * Show the remove button if:
+     *
+     * Content is editable
+     * We have a value
+     * We have a remove event to trigger
+     *
+     * OR
+     *
+     * We're being force to show the remove button (Used by PPDD)
+     */
+    private shouldShowRemove;
+    viewOptions(): ObjectHash;
+    onRender(): void;
+    onClose(): void;
+}
+export {};

package/dist/src/shared/components/typeahead-input/templates/index.d.ts

@@ -0,0 +1,4 @@
+import Loading from './Loading.hbs';
+import NotFound from './NotFound.hbs';
+import Result from './Result.hbs';
+export { Loading, NotFound, Result };

package/dist/src/shared/components/typeahead-list/TypeaheadListComponent.d.ts

@@ -0,0 +1,33 @@
+import { ObjectHash } from 'backbone';
+import { Core } from '@clickview/common';
+interface TypeaheadListComponentOptions extends Core.ComponentCollectionOptions {
+    collection: Core.Collection;
+    channelName: string;
+    typeaheadConfig: any;
+    selectEvent: string;
+    inputId: string;
+    placeholderText: string;
+    modelType: string;
+    removeEvent?: string;
+    editable?: boolean;
+}
+export declare class TypeaheadListComponentCollection extends Core.ComponentCollection {
+    options: TypeaheadListComponentOptions;
+    constructor(options: TypeaheadListComponentOptions);
+    get name(): string;
+    get childViewOptions(): TypeaheadListComponentOptions;
+    get childView(): typeof TypeaheadListComponent;
+}
+declare class TypeaheadListComponent extends Core.Component {
+    options: TypeaheadListComponentOptions;
+    constructor(options: TypeaheadListComponentOptions);
+    get name(): string;
+    get template(): string;
+    get modelId(): string;
+    get bindings(): ObjectHash;
+    regions(): ObjectHash;
+    private renderTypeahead;
+    viewOptions(): ObjectHash;
+    onRender(): void;
+}
+export {};

package/dist/src/shared/components/user-options-dropdown/UserOptionsDropdownComponent.d.ts

@@ -0,0 +1,20 @@
+import { ObjectHash } from 'backbone';
+import { Core } from '@clickview/common';
+import { DropdownChildOptions, DropdownDisplayOptions } from "..";
+import { User } from "../../models";
+interface UserOptionsDropdownComponentOptions extends Core.ComponentOptions<User> {
+    childOptions?: DropdownChildOptions;
+    displayOptions?: DropdownDisplayOptions;
+}
+export declare class UserOptionsDropdownComponent extends Core.Component<User> {
+    protected options: UserOptionsDropdownComponentOptions;
+    constructor(options: UserOptionsDropdownComponentOptions);
+    get name(): string;
+    get className(): string;
+    get template(): string;
+    regions(): ObjectHash;
+    private getExtraClasses;
+    viewOptions(): ObjectHash;
+    onRender(): void;
+}
+export {};