interface ViewHideEvent extends ViewEvent {
        view?: kendo.mobile.ui.View;
    }


interface ViewInitEvent extends ViewEvent {
        view?: kendo.mobile.ui.View;
    }


interface ViewShowEvent extends ViewEvent {
        view?: kendo.mobile.ui.View;
    }


interface ViewTransitionStartEvent extends ViewEvent {
        type?: string;
    }


interface ViewTransitionEndEvent extends ViewEvent {
        type?: string;
    }


interface WorkbookSheetColumn {
        autoWidth?: boolean;
        index?: number;
        width?: number;
    }


interface WorkbookSheetFilter {
        from?: number;
        to?: number;
    }


interface WorkbookSheetFreezePane {
        colSplit?: number;
        rowSplit?: number;
    }


interface WorkbookSheetRowCellBorderBottom {
        color?: string;
        size?: number;
    }


interface WorkbookSheetRowCellBorderLeft {
        color?: string;
        size?: number;
    }


interface WorkbookSheetRowCellBorderRight {
        color?: string;
        size?: number;
    }


interface WorkbookSheetRowCellBorderTop {
        color?: string;
        size?: number;
    }


interface WorkbookSheetRowCell {
        background?: string;
        borderBottom?: WorkbookSheetRowCellBorderBottom;
        borderLeft?: WorkbookSheetRowCellBorderLeft;
        borderTop?: WorkbookSheetRowCellBorderTop;
        borderRight?: WorkbookSheetRowCellBorderRight;
        bold?: boolean;
        color?: string;
        colSpan?: number;
        fontFamily?: string;
        fontName?: string;
        fontSize?: number;
        format?: string;
        formula?: string;
        hAlign?: string;
        index?: any;
        italic?: boolean;
        rowSpan?: number;
        textAlign?: string;
        underline?: boolean;
        wrap?: boolean;
        vAlign?: string;
        verticalAlign?: string;
        value?: Date|number|string|boolean;
    }


interface WorkbookSheetRow {
        cells?: WorkbookSheetRowCell[];
        index?: number;
        height?: number;
        type?: string;
    }


interface WorkbookSheet {
        columns?: WorkbookSheetColumn[];
        freezePane?: WorkbookSheetFreezePane;
        frozenColumns?: number;
        frozenRows?: number;
        filter?: WorkbookSheetFilter;
        mergedCells?: any;
        name?: string;
        rows?: WorkbookSheetRow[];
        showGridLines?: boolean;
        title?: string;
    }


interface WorkbookOptions {
        name?: string;
        creator?: string;
        date?: Date;
        sheets?: WorkbookSheet[];
    }


interface WorkbookEvent {
        sender: Workbook;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


interface PDFOptions  {

        creator?: string;
        date?: Date;
        imgDPI?: number;
        keywords?: string;
        landscape?: boolean;
        margin?: any;
        paperSize?: any;
        subject?: string;
        title?: string;

    }


interface HTMLElement {
    kendoBindingTarget: kendo.data.BindingTarget;
}


interface JQueryAjaxSettings {
}


interface JQueryXHR {
}


interface JQueryEventObject {
}


interface JQueryPromise<T> {
}


enum FloatingActionButtonPositionMode {
        fixed,
        absolute,
    }


enum FloatingActionButtonShape {
        rounded,
        pill,
        circle
    }


enum FloatingActionButtonSize {
        small,
        medium,
        large
    }


enum FloatingActionButtonThemeColor {
        primary,
        secondary,
        tertiary,
        info,
        success,
        warning,
        error,
        dark,
        light,
        inverse
    }


type AllEditorOptions = AutoCompleteOptions |
        ColorPickerOptions |
        ComboBoxOptions |
        DateInputOptions |
        DatePickerOptions |
        DateTimePickerOptions |
        DropDownTreeOptions |
        EditorOptions |
        MaskedTextBoxOptions |
        MultiColumnComboBoxOptions |
        MultiSelectOptions |
        NumericTextBoxOptions |
        RatingOptions |
        SliderOptions |
        SwitchOptions |
        TimePickerOptions |
        DropDownListOptions;


static extend(prototype: Object): Class;


static extend(prototype: Object): Observable;


init(...args: any[]): void;


bind(eventName: string, handler: Function): Observable;


bind(events: string[], handler: Function): Observable;


bind(events: string[], handlers: { [eventName: string]: Function}): Observable;


one(eventName: string, handler: Function): Observable;


one(events: string[], handler: Function): Observable;


one(events: string[], handlers: { [eventName: string]: Function}): Observable;


first(eventName: string, handler: Function): Observable;


first(events: string[], handler: Function): Observable;


first(events: string[], handlers: { [eventName: string]: Function}): Observable;


trigger(eventName: string, e?: any): boolean;


unbind(eventName?: string, handler?: any): Observable;


angular(eventName: string, handler: Function): void;


static defaultThreshold(value: number): void;


static minHold(value: number): void;


preventIfMoving(e?: any): void;


capture(): void;


cancel(): void;


notify(eventName?: string, data?: any): boolean;


// API
press(x: any, y: any, target: any): void;


move(x: any, y: any): void;


end(x: any, y: any): void;


init(element: Element, options?: ViewOptions): void;


init(element: string, options?: ViewOptions): void;


render(container?: any): JQuery;


showIn(selector: string, view: View, transitionClass?: string): void;


start(options: Object): void;


stop(): void;


change(callback: Function): void;


navigate(location: string, silent?: boolean): void;


callback(url: string): void;


worksWith(url: string): void;


init(options?: RouterOptions): void;


route(route: string, callback: Function): void;


replace(location: string, silent?: boolean): void;


change(e: Object): void;


start(source: kendo.Observable): void;


stop(source: kendo.Observable): void;


get (): any;


set (value: any): void;


get (): void;


render(value: Object): string;


static extend(prototype: Object): Binder;


init(element: any, bindings: Bindings, options?: BinderOptions): void;


bind(binding: Binding, attribute: string): void;


refresh(): void;


refresh(attribute: string): void;


dataType(): string;


parsedValue(): any;


init(value?: any): void;


get(name: string): any;


parent(): ObservableObject;


set(name: string, value: any): void;


toJSON(): Object;


static define(options: DataSourceSchemaModelWithFieldsObject): typeof Model;


static define(options: DataSourceSchemaModelWithFieldsArray): typeof Model;


init(data?: any): void;


accept(data?: any): void;


editable(field: string): boolean;


isNew(): boolean;


static define(options: DataSourceSchemaModelWithFieldsObject): typeof SchedulerEvent;


static define(options: DataSourceSchemaModelWithFieldsArray): typeof SchedulerEvent;


init(data?: SchedulerEventData): void;


clone(options: any, updateUid: boolean): SchedulerEvent;


duration(): number;


expand(start: Date, end: Date, zone: any): SchedulerEvent[];


update(eventInfo: SchedulerEventData): void;


isMultiDay(): boolean;


isException(): boolean;


isOccurrence(): boolean;


isRecurring(): boolean;


isRecurrenceHead(): boolean;


toOccurrence(options: any): SchedulerEvent;


static define(options: DataSourceSchemaModelWithFieldsObject): typeof TreeListModel;


static define(options: DataSourceSchemaModelWithFieldsArray): typeof TreeListModel;


loaded(value: boolean): void;


loaded(): boolean;


load(model: kendo.data.TreeListModel): JQueryPromise<any>;


childNodes(model: kendo.data.TreeListModel): kendo.data.TreeListModel[];


rootNodes(): kendo.data.TreeListModel[];


parentNode(model: kendo.data.TreeListModel): kendo.data.TreeListModel;


level(model: kendo.data.TreeListModel): number;


level(model: any): number;


add(model: Object): kendo.data.TreeListModel;


add(model: kendo.data.TreeListModel): kendo.data.TreeListModel;


at(index: number): kendo.data.TreeListModel;


cancelChanges(model?: kendo.data.TreeListModel): void;


get(id: any): kendo.data.TreeListModel;


getByUid(uid: string): kendo.data.TreeListModel;


indexOf(value: kendo.data.TreeListModel): number;


insert(index: number, model: kendo.data.TreeListModel): kendo.data.TreeListModel;


insert(index: number, model: Object): kendo.data.TreeListModel;


remove(model: kendo.data.TreeListModel): void;


static define(options: DataSourceSchemaModelWithFieldsObject): typeof GanttTask;


static define(options: DataSourceSchemaModelWithFieldsArray): typeof GanttTask;


static define(options: DataSourceSchemaModelWithFieldsObject): typeof GanttDependency;


static define(options: DataSourceSchemaModelWithFieldsArray): typeof GanttDependency;


append(model: any): void;


level(): number;


load(): void;


parentNode(): Node;


add(model: Object): kendo.data.SchedulerEvent;


add(model: kendo.data.SchedulerEvent): kendo.data.SchedulerEvent;


at(index: number): kendo.data.SchedulerEvent;


cancelChanges(model?: kendo.data.SchedulerEvent): void;


get(id: any): kendo.data.SchedulerEvent;


getByUid(uid: string): kendo.data.SchedulerEvent;


indexOf(value: kendo.data.SchedulerEvent): number;


insert(index: number, model: kendo.data.SchedulerEvent): kendo.data.SchedulerEvent;


insert(index: number, model: Object): kendo.data.SchedulerEvent;


remove(model: kendo.data.SchedulerEvent): void;


expand(start: Date, end: Date): kendo.data.SchedulerEvent;


add(model: Object): kendo.data.GanttTask;


add(model: kendo.data.GanttTask): kendo.data.GanttTask;


at(index: number): kendo.data.GanttTask;


cancelChanges(model?: kendo.data.GanttTask): void;


get(id: any): kendo.data.GanttTask;


getByUid(uid: string): kendo.data.GanttTask;


indexOf(value: kendo.data.GanttTask): number;


insert(index: number, model: Object): kendo.data.GanttTask;


insert(index: number, model: kendo.data.GanttTask): kendo.data.GanttTask;


remove(model: kendo.data.GanttTask): void;


add(model: Object): kendo.data.GanttDependency;


add(model: kendo.data.GanttDependency): kendo.data.GanttDependency;


at(index: number): kendo.data.GanttDependency;


cancelChanges(model?: kendo.data.GanttDependency): void;


get(id: any): kendo.data.GanttDependency;


getByUid(uid: string): kendo.data.GanttDependency;


indexOf(value: kendo.data.GanttDependency): number;


insert(index: number, model: Object): kendo.data.GanttDependency;


insert(index: number, model: kendo.data.GanttDependency): kendo.data.GanttDependency;


remove(model: kendo.data.GanttDependency): void;


init(options?: HierarchicalDataSourceOptions): void;


init(options?: FileManagerDataSourceOptions): void;


axes(): PivotSchemaAxes;


init(options?: PivotDataSourceOptions): void;


catalog(val: string): void;


catalog(): string;


columns(val: string[]): void;


columns(): string[];


cube(val: string): void;


cube(): string;


discover(options: PivotDiscoverRequestOptions): JQueryPromise<any>;


measures(val: string[]): void;


measures(): string[];


measuresAxis(): string;


rows(val: string[]): void;


rows(): string[];


schemaCatalogs(): JQueryPromise<any>;


schemaCubes(): JQueryPromise<any>;


schemaDimensions(): JQueryPromise<any>;


schemaHierarchies(): JQueryPromise<any>;


schemaLevels(): JQueryPromise<any>;


schemaMeasures(): JQueryPromise<any>;


init(array: any[]): void;


empty(): void;


every(callback: (item: Object, index: number, source: ObservableArray) => boolean): boolean;


filter(callback: (item: Object, index: number, source: ObservableArray) => boolean): any[];


find(callback: (item: Object, index: number, source: ObservableArray) => boolean): any;


forEach(callback: (item: Object, index: number, source: ObservableArray) => void ): void;


indexOf(item: any): number;


join(separator: string): string;


map(callback: (item: Object, index: number, source: ObservableArray) => any): any[];


pop(): ObservableObject;


push(...items: any[]): number;


remove(item: Object): void;


shift(): any;


slice(begin: number, end?: number): any[];


some(callback: (item: Object, index: number, source: ObservableArray) => boolean): boolean;


sort(compareFn?: (a: any, b: any) => number): any[];


splice(start: number): any[];


splice(start: number, deleteCount: number, ...items: any[]): any[];


toJSON(): any[];


unshift(...items: any[]): number;


wrap(object: Object, parent: Object): any;


wrapAll(source: Object, target: Object): any;


static create(options?: DataSourceOptions): DataSource;


init(options?: DataSourceOptions): void;


add(model: Object): kendo.data.Model;


add(model: kendo.data.Model): kendo.data.Model;


aggregate(val: any): void;


aggregate(): any;


aggregates(): any;


at(index: number): kendo.data.ObservableObject;


cancelChanges(model?: kendo.data.Model): void;


data(): kendo.data.ObservableArray;


data(value: any): void;


fetch(callback?: Function): JQueryPromise<any>;


filter(filters: DataSourceFilterItem): void;


filter(filters: DataSourceFilterItem[]): void;


filter(filters: DataSourceFilters): void;


filter(): DataSourceFilters;


get(id: any): kendo.data.Model;


getByUid(uid: string): kendo.data.Model;


group(groups: any): void;


group(): any;


hasChanges(): boolean;


indexOf(value: kendo.data.ObservableObject): number;


insert(index: number, model: kendo.data.Model): kendo.data.Model;


insert(index: number, model: Object): kendo.data.Model;


online(value: boolean): void;


online(): boolean;


offlineData(data: any[]): void;


offlineData(): any[];


page(): number;


page(page: number): void;


pageSize(): number;


pageSize(size: number): void;


pushCreate(model: Object): void;


pushCreate(models: any[]): void;


pushInsert(index: number, model: Object): void;


pushInsert(index: number, models: any[]): void;


pushDestroy(model: Object): void;


pushDestroy(models: any[]): void;


pushUpdate(model: Object): void;


pushUpdate(models: any[]): void;


query(options?: any): JQueryPromise<any>;


read(data?: any): JQueryPromise<any>;


remove(model: kendo.data.ObservableObject): void;


skip(): number;


sort(sort: DataSourceSortItem): void;


sort(sort: DataSourceSortItem[]): void;


sort(): DataSourceSortItem[];


sync(): JQueryPromise<any>;


total(): number;


totalPages(): number;


view(): kendo.data.ObservableArray;


static process(data: any[], options: DataSourceTransportReadOptionsData): QueryResult;


toArray(): any[];


range(intex: number, count: number): kendo.data.Query;


skip(count: number): kendo.data.Query;


take(count: number): kendo.data.Query;


select(selector: Function): kendo.data.Query;


order(selector: string, dir?: string): kendo.data.Query;


order(selector: Function, dir?: string): kendo.data.Query;


filter(filters: DataSourceFilterItem): kendo.data.Query;


filter(filters: DataSourceFilterItem[]): kendo.data.Query;


filter(filters: DataSourceFilters): kendo.data.Query;


group(descriptors: DataSourceGroupItem): kendo.data.Query;


group(descriptors: DataSourceGroupItem[]): kendo.data.Query;


change(): void;


container(): Element;


template(): String;


add(index: Number, items: any[]): void;


remove(index: Number, items: any[]): void;


render(): void;


value(): any;


static extend(prototype: Object): Widget;


init(element: Element, options?: Object): void;


init(element: JQuery, options?: Object): void;


init(selector: String, options?: Object): void;


setOptions(options: Object): void;


resize(force?: boolean): void;


cancelHold(): void;


static destroyGroup(groupName: string): void;


static extend(prototype: Object): any;


exec?(): void;


init?(options: any): void;


removeItems?(items: any): void;


getResizable(): void;


init(element?: any, options?: ApplicationOptions): void;


changeLoadingMessage(text: string): void;


hideLoading(): void;


navigate(url: string, transition?: string): void;


replace(url: string, transition?: string): void;


scroller(): kendo.mobile.ui.Scroller;


showLoading(): void;


skin(skin: string): string;


view(): kendo.mobile.ui.View;


static extend(proto: Object): ActionSheet;


static extend(proto: Object): Alert;


static extend(proto: Object): AppBar;


static extend(proto: Object): AutoComplete;


dataItem(index: number): any;


dataItem(index: Element): any;


dataItem(index: JQuery): any;


enable(enable: boolean): void;


items(): any;


readonly(readonly: boolean): void;


search(word: string): void;


select(item: string): void;


select(item: Element): void;


select(item: JQuery): void;


setDataSource(dataSource: kendo.data.DataSource): void;


suggest(value: string): void;


value(): string;


value(value: string): void;


static extend(proto: Object): Badge;


hide(): void;


icon(icon: string): void;


setOptions(options: any): void;


shape(shape: string): void;


show(): void;


text(text: string): void;


text(text: number): void;


themeColor(themeColor: string): void;


static extend(proto: Object): BottomNavigation;


add(item: any, beforeElement?: HTMLElement): void;


add(item: any, beforeElement?: JQuery): void;


enable(element: HTMLElement, state?: boolean): void;


enable(element: JQuery, state?: boolean): void;


item(index: number): JQuery;


item(index: string): JQuery;


itemById(id: string): JQuery;


items(): JQuery;


remove(element: HTMLElement): void;


remove(element: JQuery): void;


select(element: HTMLElement, state?: boolean): JQuery;


select(element: JQuery, state?: boolean): JQuery;


showText(show: boolean): void;


static extend(proto: Object): Breadcrumb;


value(path: string): void;


items(items: BreadcrumbItem[]): void;


static extend(proto: Object): Button;


enable(toggle: boolean): void;


static extend(proto: Object): ButtonGroup;


badge(button: string, value: string): string;


badge(button: string, value: boolean): string;


badge(button: number, value: string): string;


badge(button: number, value: boolean): string;


current(): JQuery;


select(li: JQuery): void;


select(li: number): void;


static extend(proto: Object): Calendar;


current(): Date;


max(): Date;


max(value: Date): void;


max(value: string): void;


min(): Date;


min(value: Date): void;


min(value: string): void;


navigate(value: Date, view: string): void;


navigateDown(value: Date): void;


navigateToFuture(): void;


navigateToPast(): void;


navigateUp(): void;


selectDates(): void;


value(): Date;


value(value: Date): void;


view(): any;


static extend(proto: Object): Chat;


getUser(): any;


postMessage(message: string): void;


renderAttachments(options: any, sender: any): void;


renderMessage(message: any, sender: any): void;


renderSuggestedActions(suggestedActions: any): void;


static extend(proto: Object): CheckBoxGroup;


checkAll(select: boolean): void;


enableItem(enable: boolean, index: number): void;


value(value: any): void;


static extend(proto: Object): ColorPalette;


value(color?: string): void;


color(): kendo.Color;


color(color?: kendo.Color): void;


enable(enable?: boolean): void;


static extend(proto: Object): ColorPicker;


static extend(proto: Object): ComboBox;


dataItem(index?: number): any;


select(): number;


select(li: Function): void;


text(): string;


toggle(toggle: boolean): void;


static extend(proto: Object): Confirm;


open(): kendo.ui.Confirm;


static extend(proto: Object): ContextMenu;


append(item: any, referenceItem?: string): kendo.ui.ContextMenu;


append(item: any, referenceItem?: JQuery): kendo.ui.ContextMenu;


close(element: Element): kendo.ui.ContextMenu;


close(element: JQuery): kendo.ui.ContextMenu;


enable(element: string, enable: boolean): kendo.ui.ContextMenu;


enable(element: Element, enable: boolean): kendo.ui.ContextMenu;


enable(element: JQuery, enable: boolean): kendo.ui.ContextMenu;


findByUid(uid: string): JQuery;


insertAfter(item: any, referenceItem: string): kendo.ui.ContextMenu;


insertAfter(item: any, referenceItem: Element): kendo.ui.ContextMenu;


insertAfter(item: any, referenceItem: JQuery): kendo.ui.ContextMenu;


insertBefore(item: any, referenceItem: string): kendo.ui.ContextMenu;


insertBefore(item: any, referenceItem: Element): kendo.ui.ContextMenu;


insertBefore(item: any, referenceItem: JQuery): kendo.ui.ContextMenu;


open(x: number, y?: number): kendo.ui.ContextMenu;


open(x: Element, y?: number): kendo.ui.ContextMenu;


open(x: JQuery, y?: number): kendo.ui.ContextMenu;


remove(element: string): kendo.ui.ContextMenu;


remove(element: Element): kendo.ui.ContextMenu;


remove(element: JQuery): kendo.ui.ContextMenu;


static extend(proto: Object): DateInput;


static extend(proto: Object): DatePicker;


static extend(proto: Object): DateRangePicker;


range(): any;


range(range: DateRangePickerRange): void;


static extend(proto: Object): DateTimePicker;


close(view: string): void;


open(view: string): void;


toggle(view: string): void;


static extend(proto: Object): Dialog;


center(): kendo.ui.Dialog;


close(): kendo.ui.Dialog;


content(): string;


content(content?: string): kendo.ui.Dialog;


content(content?: JQuery): kendo.ui.Dialog;


open(): kendo.ui.Dialog;


title(): string;


title(text?: string): kendo.ui.Dialog;


toFront(): kendo.ui.Dialog;


static extend(proto: Object): Drawer;


static extend(proto: Object): DropDownList;


dataItem(index?: JQuery): any;


static extend(proto: Object): DropDownTree;


setDataSource(dataSource: kendo.data.HierarchicalDataSource): void;


toggle(toggle?: boolean): void;


static extend(proto: Object): Editor;


createRange(document?: Document): Range;


encodedValue(): string;


exec(name: string, params: any): void;


getRange(): Range;


getSelection(): Selection;


paste(html: string, options: any): void;


selectedHtml(): string;


saveAsPDF(): JQueryPromise<any>;


selectRange(range: Range): void;


update(): void;


state(toolName: string): boolean;


static extend(proto: Object): ExpansionPanel;


toggle(expand: boolean, animation: boolean): void;


static extend(proto: Object): FileManager;


path(): string;


view(): string;


view(view?: string): void;


navigate(path: string): void;


executeCommand(command: string, args?: any): void;


getSelected(): any | any[];


getSize(): any;


setDataSource(dataSource: kendo.data.FileManagerDataSource): void;


static extend(proto: Object): Filter;


applyFilter(): void;


static extend(proto: Object): FilterMenu;


static extend(proto: Object): FlatColorPicker;


static extend(proto: Object): FloatingActionButton;


static extend(proto: Object): Form;


validate(): void;


static extend(proto: Object): Gantt;


clearSelection(): void;


dataItem(row: string): kendo.data.GanttTask;


dataItem(row: Element): kendo.data.GanttTask;


dataItem(row: JQuery): kendo.data.GanttTask;


date(date?: Date): Date;


range(range?: any): any;


refreshDependencies(): void;


removeDependency(dependency: string): void;


removeDependency(dependency: kendo.data.GanttDependency): void;


removeTask(task: string): void;


removeTask(task: kendo.data.GanttTask): void;


select(): JQuery;


select(row: string): void;


select(row: Element): void;


select(row: JQuery): void;


setDataSource(dataSource: kendo.data.GanttDataSource): void;


setDependenciesDataSource(dataSource: kendo.data.GanttDependencyDataSource): void;


view(): kendo.ui.GanttView;


view(type?: string): void;


static extend(proto: Object): Grid;


addRow(): void;


autoFitColumn(column: number): void;


autoFitColumn(column: string): void;


autoFitColumn(column: any): void;


cancelChanges(): void;


cancelRow(): void;


cellIndex(cell: string): number;


cellIndex(cell: Element): number;


cellIndex(cell: JQuery): number;


closeCell(isCancel?: boolean): void;


collapseGroup(row: string): void;


collapseGroup(row: Element): void;


collapseGroup(row: JQuery): void;


collapseRow(row: string): void;


collapseRow(row: Element): void;


collapseRow(row: JQuery): void;


current(cell: JQuery): void;


dataItem(row: string): kendo.data.ObservableObject;


dataItem(row: Element): kendo.data.ObservableObject;


dataItem(row: JQuery): kendo.data.ObservableObject;


dataItems(): kendo.data.ObservableArray;


editCell(cell: JQuery): void;


editRow(row: JQuery): void;


expandGroup(row: string): void;


expandGroup(row: Element): void;


expandGroup(row: JQuery): void;


expandRow(row: string): void;


expandRow(row: Element): void;


expandRow(row: JQuery): void;


getOptions(): GridOptions;


hideColumn(column: number): void;


hideColumn(column: string): void;


hideColumn(column: any): void;


lockColumn(column: number): void;


lockColumn(column: string): void;


removeRow(row: string): void;


removeRow(row: Element): void;


removeRow(row: JQuery): void;


reorderColumn(destIndex: number, column: any): void;


resizeColumn(column: any, value: number): void;


saveAsExcel(): void;


saveChanges(): void;


saveRow(): void;


select(rows: string): void;


select(rows: Element): void;


select(rows: JQuery): void;


selectedKeyNames(): any;


showColumn(column: number): void;


showColumn(column: string): void;


showColumn(column: any): void;


stickColumn(column: number): void;


stickColumn(column: string): void;


unlockColumn(column: number): void;


unlockColumn(column: string): void;


unstickColumn(column: number): void;


unstickColumn(column: string): void;


static extend(proto: Object): ImageEditor;


drawImage(imageUrl: string): JQueryPromise<any>;


drawCanvas(image: any): void;


getCanvasElement(): HTMLElement;


getCurrent2dContext(): any;


getCurrentImage(): HTMLElement;


getZoomLevel(): number;


static extend(proto: Object): ListBox;


dataItem(element: JQuery): kendo.data.ObservableObject;


dataItem(element: Element): kendo.data.ObservableObject;


dataItem(element: string): kendo.data.ObservableObject;


enable(element: JQuery, enable?: boolean): void;


enable(element: Element, enable?: boolean): void;


enable(element: string, enable?: boolean): void;


reorder(element: JQuery, index: number): void;


reorder(element: Element, index: number): void;


reorder(element: string, index: number): void;


remove(element: Element): void;


remove(element: string): void;


remove(element: any): void;


select(items: JQuery): void;


select(items: any): void;


static extend(proto: Object): ListView;


add(): void;


edit(item: JQuery): void;


remove(item: any): void;


save(): void;


static extend(proto: Object): Loader;


static extend(proto: Object): MaskedTextBox;


raw(): string;


static extend(proto: Object): MediaPlayer;


fullScreen(): boolean;


fullScreen(value: boolean): void;


media(): any;


media(value: any): void;


volume(): number;


volume(value: number): void;


mute(value: boolean): boolean;


isEnded(): boolean;


isPaused(): boolean;


isPlaying(): boolean;


play(): void;


seek(milliseconds: number): number;


titlebar(): JQuery;


toolbar(): kendo.ui.ToolBar;


static extend(proto: Object): Menu;


append(item: any, referenceItem?: string): kendo.ui.Menu;


append(item: any, referenceItem?: JQuery): kendo.ui.Menu;


close(element: string): kendo.ui.Menu;


close(element: Element): kendo.ui.Menu;


close(element: JQuery): kendo.ui.Menu;


enable(element: string, enable: boolean): kendo.ui.Menu;


enable(element: Element, enable: boolean): kendo.ui.Menu;


enable(element: JQuery, enable: boolean): kendo.ui.Menu;


insertAfter(item: any, referenceItem: string): kendo.ui.Menu;


insertAfter(item: any, referenceItem: Element): kendo.ui.Menu;


insertAfter(item: any, referenceItem: JQuery): kendo.ui.Menu;


insertBefore(item: any, referenceItem: string): kendo.ui.Menu;


insertBefore(item: any, referenceItem: Element): kendo.ui.Menu;


insertBefore(item: any, referenceItem: JQuery): kendo.ui.Menu;


open(element: string): kendo.ui.Menu;


open(element: Element): kendo.ui.Menu;


open(element: JQuery): kendo.ui.Menu;


remove(element: string): kendo.ui.Menu;


remove(element: Element): kendo.ui.Menu;


remove(element: JQuery): kendo.ui.Menu;


static extend(proto: Object): MultiColumnComboBox;


static extend(proto: Object): MultiSelect;


dataItems(): any;


static extend(proto: Object): MultiViewCalendar;


selectDates(): any;


selectDates(dates: any): void;


selectRange(): any;


selectRange(range: any): void;


static extend(proto: Object): Notification;


error(data: any): void;


error(data: string): void;


error(data: Function): void;


getNotifications(): JQuery;


info(data: any): void;


info(data: string): void;


info(data: Function): void;


show(data: any, type: string): void;


show(data: string, type: string): void;


show(data: Function, type: string): void;


showText(data: any, type: string): void;


showText(data: string, type: string): void;


showText(data: Function, type: string): void;


success(data: any): void;


success(data: string): void;


success(data: Function): void;


warning(data: any): void;


warning(data: string): void;


warning(data: Function): void;


static extend(proto: Object): NumericTextBox;


max(): number;


max(value: number): void;


min(): number;


min(value: number): void;


step(): number;


step(value: number): void;


step(value: string): void;


value(): number;


value(value: number): void;


static extend(proto: Object): PDFViewer;


fromFile(): void;


activatePage(): void;


loadPage(): void;


execute(): void;


static extend(proto: Object): Pager;


static extend(proto: Object): PanelBar;


append(item: string, referenceItem?: string): kendo.ui.PanelBar;


append(item: string, referenceItem?: Element): kendo.ui.PanelBar;


append(item: string, referenceItem?: JQuery): kendo.ui.PanelBar;


append(item: Element, referenceItem?: string): kendo.ui.PanelBar;


append(item: Element, referenceItem?: Element): kendo.ui.PanelBar;


append(item: Element, referenceItem?: JQuery): kendo.ui.PanelBar;


append(item: JQuery, referenceItem?: string): kendo.ui.PanelBar;


append(item: JQuery, referenceItem?: Element): kendo.ui.PanelBar;


append(item: JQuery, referenceItem?: JQuery): kendo.ui.PanelBar;


append(item: any, referenceItem?: string): kendo.ui.PanelBar;


append(item: any, referenceItem?: Element): kendo.ui.PanelBar;


append(item: any, referenceItem?: JQuery): kendo.ui.PanelBar;


collapse(element: string, useAnimation: boolean): kendo.ui.PanelBar;


collapse(element: Element, useAnimation: boolean): kendo.ui.PanelBar;


collapse(element: JQuery, useAnimation: boolean): kendo.ui.PanelBar;


dataItem(node: JQuery): kendo.data.Node;


dataItem(node: Element): kendo.data.Node;


dataItem(node: string): kendo.data.Node;


enable(element: string, enable: boolean): void;


enable(element: Element, enable: boolean): void;


enable(element: JQuery, enable: boolean): void;


expand(element: string, useAnimation: boolean): kendo.ui.PanelBar;


expand(element: Element, useAnimation: boolean): kendo.ui.PanelBar;


expand(element: JQuery, useAnimation: boolean): kendo.ui.PanelBar;


insertAfter(item: string, referenceItem: string): void;


insertAfter(item: string, referenceItem: Element): void;


insertAfter(item: string, referenceItem: JQuery): void;


insertAfter(item: Element, referenceItem: string): void;


insertAfter(item: Element, referenceItem: Element): void;


insertAfter(item: Element, referenceItem: JQuery): void;


insertAfter(item: JQuery, referenceItem: string): void;


insertAfter(item: JQuery, referenceItem: Element): void;


insertAfter(item: JQuery, referenceItem: JQuery): void;


insertAfter(item: any, referenceItem: string): void;


insertAfter(item: any, referenceItem: Element): void;


insertAfter(item: any, referenceItem: JQuery): void;


insertBefore(item: string, referenceItem: string): kendo.ui.PanelBar;


insertBefore(item: string, referenceItem: Element): kendo.ui.PanelBar;


insertBefore(item: string, referenceItem: JQuery): kendo.ui.PanelBar;


insertBefore(item: Element, referenceItem: string): kendo.ui.PanelBar;


insertBefore(item: Element, referenceItem: Element): kendo.ui.PanelBar;


insertBefore(item: Element, referenceItem: JQuery): kendo.ui.PanelBar;


insertBefore(item: JQuery, referenceItem: string): kendo.ui.PanelBar;


insertBefore(item: JQuery, referenceItem: Element): kendo.ui.PanelBar;


insertBefore(item: JQuery, referenceItem: JQuery): kendo.ui.PanelBar;


insertBefore(item: any, referenceItem: string): kendo.ui.PanelBar;


insertBefore(item: any, referenceItem: Element): kendo.ui.PanelBar;


insertBefore(item: any, referenceItem: JQuery): kendo.ui.PanelBar;


reload(element: string): void;


reload(element: Element): void;


reload(element: JQuery): void;


select(element?: string): void;


select(element?: Element): void;


select(element?: JQuery): void;


static extend(proto: Object): PivotConfigurator;


setDataSource(dataSource: kendo.data.PivotDataSource): void;


static extend(proto: Object): PivotGrid;


cellInfo(columnIndex: number, rowIndex: number): any;


cellInfoByElement(cell: string): any;


cellInfoByElement(cell: Element): any;


cellInfoByElement(cell: JQuery): any;


static extend(proto: Object): Popup;


position(): void;


visible(): boolean;


static extend(proto: Object): ProgressBar;


value(value: boolean|number): void;


static extend(proto: Object): Prompt;


static extend(proto: Object): RadioGroup;


static extend(proto: Object): RangeSlider;


value(startEndArray: any): void;


values(): any;


values(selectionStart: number, selectionEnd: number): void;


resize(): void;


static extend(proto: Object): Rating;


readonly(enable: boolean): void;


static extend(proto: Object): ResponsivePanel;


static extend(proto: Object): Scheduler;


addEvent(data: any): void;


cancelEvent(): void;


data(): void;


date(): Date;


date(value?: Date): void;


editEvent(event: string): void;


editEvent(event: kendo.data.SchedulerEvent): void;


occurrenceByUid(uid: string): kendo.data.SchedulerEvent;


occurrencesInRange(start: Date, end: Date): any;


removeEvent(event: string): void;


removeEvent(event: kendo.data.SchedulerEvent): void;


resourcesBySlot(slot: any): any;


saveEvent(): void;


select(): void;


select(options: SchedulerEvent[] | SchedulerSelectOptions): void;


setDataSource(dataSource: kendo.data.SchedulerDataSource): void;


slotByPosition(xPosition: number, yPosition: number): any;


slotByElement(element: Element): any;


slotByElement(element: JQuery): any;


view(): kendo.ui.SchedulerView;


viewName(): string;


static extend(proto: Object): ScrollView;


content(content: string): void;


content(content: JQuery): void;


next(): void;


prev(): void;


scrollTo(page: number, instant: boolean): void;


static extend(proto: Object): SkeletonContainer;


static extend(proto: Object): Slider;


static extend(proto: Object): Sortable;


indexOf(element: JQuery): number;


static extend(proto: Object): Splitter;


ajaxRequest(pane: string, url: string, data: any): void;


ajaxRequest(pane: string, url: string, data: string): void;


ajaxRequest(pane: Element, url: string, data: any): void;


ajaxRequest(pane: Element, url: string, data: string): void;


ajaxRequest(pane: JQuery, url: string, data: any): void;


ajaxRequest(pane: JQuery, url: string, data: string): void;


append(config?: any): JQuery;


collapse(pane: string): void;


collapse(pane: Element): void;


collapse(pane: JQuery): void;


expand(pane: string): void;


expand(pane: Element): void;


expand(pane: JQuery): void;


insertAfter(config: any, referencePane: string): JQuery;


insertAfter(config: any, referencePane: Element): JQuery;


insertAfter(config: any, referencePane: JQuery): JQuery;


insertBefore(config: any, referencePane: string): JQuery;


insertBefore(config: any, referencePane: Element): JQuery;


insertBefore(config: any, referencePane: JQuery): JQuery;


max(pane: string, value: string): void;


max(pane: Element, value: string): void;


max(pane: JQuery, value: string): void;


min(pane: string, value: string): void;


min(pane: Element, value: string): void;


min(pane: JQuery, value: string): void;


remove(pane: string): void;


remove(pane: Element): void;


remove(pane: JQuery): void;


size(pane: string): any;


size(pane: Element): any;


size(pane: JQuery): any;


size(pane: string, value?: string): void;


size(pane: Element, value?: string): void;


size(pane: JQuery, value?: string): void;


toggle(pane: string, expand?: boolean): void;


toggle(pane: Element, expand?: boolean): void;


toggle(pane: JQuery, expand?: boolean): void;


static extend(proto: Object): Spreadsheet;


activeSheet(): kendo.spreadsheet.Sheet;


activeSheet(sheet?: kendo.spreadsheet.Sheet): void;


cellContextMenu(): kendo.ui.ContextMenu;


rowHeaderContextMenu(): kendo.ui.ContextMenu;


colHeaderContextMenu(): kendo.ui.ContextMenu;


sheets(): any;


fromFile(blob: Blob): JQueryPromise<any>;


fromFile(blob: File): JQueryPromise<any>;


sheetByName(name: string): kendo.spreadsheet.Sheet;


sheetIndex(sheet: kendo.spreadsheet.Sheet): number;


sheetByIndex(index: number): kendo.spreadsheet.Sheet;


insertSheet(options: any): kendo.spreadsheet.Sheet;


moveSheetToIndex(sheet: kendo.spreadsheet.Sheet, index: number): void;


removeSheet(sheet: kendo.spreadsheet.Sheet): void;


renameSheet(sheet: kendo.spreadsheet.Sheet, newSheetName: string): kendo.spreadsheet.Sheet;


saveJSON(): JQueryPromise<any>;


toJSON(): any;


fromJSON(data: any): void;


defineName(name: string, value: string, hidden: boolean): void;


undefineName(name: string): void;


static extend(proto: Object): Switch;


check(): boolean;


check(check: boolean): void;


static extend(proto: Object): Stepper;


enable(value: boolean): void;


insertAt(index: number, step: kendo.stepper.StepOptions): void;


previous(): void;


removeAt(index: number): void;


select(): kendo.stepper.Step;


select(index: number): void;


steps(): kendo.stepper.Step[];


steps(steps: kendo.stepper.StepOptions[]): void;


static extend(proto: Object): TabStrip;


activateTab(item: JQuery): void;


append(tab: any): kendo.ui.TabStrip;


contentElement(itemIndex: number): Element;


contentHolder(itemIndex: number): Element;


deactivateTab(item: JQuery): void;


disable(element: string): kendo.ui.TabStrip;


disable(element: Element): kendo.ui.TabStrip;


disable(element: JQuery): kendo.ui.TabStrip;


enable(element: string, enable?: boolean): kendo.ui.TabStrip;


enable(element: Element, enable?: boolean): kendo.ui.TabStrip;


enable(element: JQuery, enable?: boolean): kendo.ui.TabStrip;


insertAfter(item: any, referenceTab: string): kendo.ui.TabStrip;


insertAfter(item: any, referenceTab: Element): kendo.ui.TabStrip;


insertAfter(item: any, referenceTab: JQuery): kendo.ui.TabStrip;


insertAfter(item: string, referenceTab: string): kendo.ui.TabStrip;


insertAfter(item: string, referenceTab: Element): kendo.ui.TabStrip;


insertAfter(item: string, referenceTab: JQuery): kendo.ui.TabStrip;


insertAfter(item: Element, referenceTab: string): kendo.ui.TabStrip;


insertAfter(item: Element, referenceTab: Element): kendo.ui.TabStrip;


insertAfter(item: Element, referenceTab: JQuery): kendo.ui.TabStrip;


insertAfter(item: JQuery, referenceTab: string): kendo.ui.TabStrip;


insertAfter(item: JQuery, referenceTab: Element): kendo.ui.TabStrip;


insertAfter(item: JQuery, referenceTab: JQuery): kendo.ui.TabStrip;


insertBefore(item: any, referenceTab: string): kendo.ui.TabStrip;


insertBefore(item: any, referenceTab: Element): kendo.ui.TabStrip;


insertBefore(item: any, referenceTab: JQuery): kendo.ui.TabStrip;


insertBefore(item: string, referenceTab: string): kendo.ui.TabStrip;


insertBefore(item: string, referenceTab: Element): kendo.ui.TabStrip;


insertBefore(item: string, referenceTab: JQuery): kendo.ui.TabStrip;


insertBefore(item: Element, referenceTab: string): kendo.ui.TabStrip;


insertBefore(item: Element, referenceTab: Element): kendo.ui.TabStrip;


insertBefore(item: Element, referenceTab: JQuery): kendo.ui.TabStrip;


insertBefore(item: JQuery, referenceTab: string): kendo.ui.TabStrip;


insertBefore(item: JQuery, referenceTab: Element): kendo.ui.TabStrip;


insertBefore(item: JQuery, referenceTab: JQuery): kendo.ui.TabStrip;


items(): HTMLCollection;


reload(element: string): kendo.ui.TabStrip;


reload(element: Element): kendo.ui.TabStrip;


reload(element: JQuery): kendo.ui.TabStrip;


remove(element: string): kendo.ui.TabStrip;


remove(element: number): kendo.ui.TabStrip;


remove(element: JQuery): kendo.ui.TabStrip;


select(element: string): void;


select(element: Element): void;


select(element: JQuery): void;


select(element: number): void;


setDataSource(dataSource: any): void;


static extend(proto: Object): TaskBoard;


addCard(data: any): void;


addColumn(data: any): void;


columns(): JQuery;


columnByStatus(status: string): JQuery;


deleteCard(cardElm: JQuery): void;


deleteColumn(columnElm: JQuery): void;


editCard(cardElm: JQuery): void;


editColumn(columnElm: JQuery): void;


enable(cardElm: JQuery): void;


enableByColumn(columnElm: JQuery, state: boolean): void;


readOnly(cardElm: JQuery): void;


readOnlyByColumn(columnElm: JQuery, state: boolean): void;


itemsByStatus(status: string): JQuery;


itemsByColumn(columnElm: JQuery): JQuery;


previewCard(cardElm: JQuery): void;


registerShortcut(selector: string, shortcut: any, options: any): void;


dataItem(cardElm: JQuery): kendo.data.ObservableObject;


columnDataItem(columnElm: JQuery): kendo.data.ObservableObject;


saveCard(): void;


saveColumn(): void;


select(cardElm: JQuery): JQuery;


setColumnsDataSource(dataSource: kendo.data.DataSource): void;


setColumnsDataSource(dataSource: any): void;


static extend(proto: Object): TileLayout;


static extend(proto: Object): TextArea;


static extend(proto: Object): TextBox;


static extend(proto: Object): TimePicker;


static extend(proto: Object): Timeline;


expand(event: string): void;


expand(event: Element): void;


expand(event: JQuery): void;


collapse(event: string): void;


collapse(event: Element): void;


collapse(event: JQuery): void;


open(event: string): void;


open(event: Element): void;


open(event: JQuery): void;


redraw(): void;


static extend(proto: Object): ToolBar;


add(command: any): void;


enable(command: string, enable: boolean): void;


enable(command: Element, enable: boolean): void;


enable(command: JQuery, enable: boolean): void;


getSelectedFromGroup(groupName: string): void;


hide(command: string): void;


hide(command: Element): void;


hide(command: JQuery): void;


remove(command: string): void;


remove(command: Element): void;


remove(command: JQuery): void;


show(command: string): void;


show(command: Element): void;


show(command: JQuery): void;


toggle(command: string, state: boolean): void;


toggle(command: Element, state: boolean): void;


toggle(command: JQuery, state: boolean): void;


static extend(proto: Object): Tooltip;


show(element: JQuery): void;


target(): JQuery;


static extend(proto: Object): Touch;


static extend(proto: Object): TreeList;


addRow(parentRow: string): void;


addRow(parentRow: Element): void;


addRow(parentRow: JQuery): void;


collapse(row: string): JQueryPromise<any>;


collapse(row: Element): JQueryPromise<any>;


collapse(row: JQuery): JQueryPromise<any>;


dataItem(row: string): kendo.data.TreeListModel;


dataItem(row: Element): kendo.data.TreeListModel;


dataItem(row: JQuery): kendo.data.TreeListModel;


expand(row: string): JQueryPromise<any>;


expand(row: Element): JQueryPromise<any>;


expand(row: JQuery): JQueryPromise<any>;


itemFor(model: kendo.data.TreeListModel): JQuery;


itemFor(model: any): JQuery;


setDataSource(dataSource: kendo.data.TreeListDataSource): void;


static extend(proto: Object): TreeView;


append(nodeData: any, parentNode?: JQuery, success?: Function): JQuery;


append(nodeData: JQuery, parentNode?: JQuery, success?: Function): JQuery;


collapse(nodes: JQuery): void;


collapse(nodes: Element): void;


collapse(nodes: string): void;


detach(node: JQuery): JQuery;


detach(node: Element): JQuery;


detach(node: string): JQuery;


enable(nodes: JQuery, enable?: boolean): void;


enable(nodes: Element, enable?: boolean): void;


enable(nodes: string, enable?: boolean): void;


enable(nodes: boolean, enable?: boolean): void;


expand(nodes: JQuery): void;


expand(nodes: Element): void;


expand(nodes: string): void;


expandPath(path: any, complete: Function): void;


expandTo(targetNode: kendo.data.Node): void;


expandTo(targetNode: any): void;


findByText(text: string): JQuery;


insertAfter(nodeData: any, referenceNode: JQuery): JQuery;


insertBefore(nodeData: any, referenceNode: JQuery): JQuery;


parent(node: JQuery): JQuery;


parent(node: Element): JQuery;


parent(node: string): JQuery;


remove(node: JQuery): void;


remove(node: Element): void;


remove(node: string): void;


select(node?: JQuery): void;


select(node?: Element): void;


select(node?: string): void;


text(node: JQuery): string;


text(node: Element): string;


text(node: string): string;


text(node: JQuery, newText: string): void;


text(node: Element, newText: string): void;


text(node: string, newText: string): void;


toggle(node: JQuery): void;


toggle(node: Element): void;


toggle(node: string): void;


updateIndeterminate(node: JQuery): void;


static extend(proto: Object): Upload;


clearAllFiles(): void;


clearFile(callback: Function): void;


clearFileByUid(uid: string): void;


disable(): void;


getFiles(): any;


pause(li: JQuery): void;


resume(li: JQuery): void;


removeAllFiles(): void;


removeFile(callback: Function): void;


removeFileByUid(uid: string): void;


toggle(enable: boolean): void;


upload(): void;


static extend(proto: Object): Validator;


errors(): any;


hideMessages(): void;


hideValidationSummary(): void;


showValidationSummary(): void;


validate(): boolean;


validateInput(input: Element): boolean;


validateInput(input: JQuery): boolean;


static extend(proto: Object): Window;


center(): kendo.ui.Window;


close(): kendo.ui.Window;


content(content?: string): kendo.ui.Window;


content(content?: JQuery): kendo.ui.Window;


isMaximized(): boolean;


isMinimized(): boolean;


maximize(): kendo.ui.Window;


minimize(): kendo.ui.Window;


open(): kendo.ui.Window;


pin(): void;


refresh(options: any): kendo.ui.Window;


restore(): kendo.ui.Window;


title(text?: string): kendo.ui.Window;


toFront(): kendo.ui.Window;


toggleMaximization(): kendo.ui.Window;


unpin(): void;


static extend(proto: Object): Wizard;


activeStep(): kendo.wizard.Step;


enableStep(index: number, enable: boolean): void;


insertAt(index: number, step: any): void;


steps(): kendo.wizard.Step[];


bbox(): kendo.geometry.Rect;


clip(): kendo.drawing.Path;


clip(clip: kendo.drawing.Path): void;


clippedBBox(): kendo.geometry.Rect;


containsPoint(point: kendo.geometry.Point): boolean;


geometry(): kendo.geometry.Arc;


geometry(value: kendo.geometry.Arc): void;


fill(color: string, opacity?: number): kendo.drawing.Arc;


opacity(): number;


opacity(opacity: number): void;


stroke(color: string, width?: number, opacity?: number): kendo.drawing.Arc;


transform(): kendo.geometry.Transformation;


transform(transform: kendo.geometry.Transformation): void;


visible(visible: boolean): void;


geometry(): kendo.geometry.Circle;


geometry(value: kendo.geometry.Circle): void;


fill(color: string, opacity?: number): kendo.drawing.Circle;


stroke(color: string, width?: number, opacity?: number): kendo.drawing.Circle;


addStop(offset: number, color: string, opacity: number): kendo.drawing.GradientStop;


removeStop(stop: kendo.drawing.GradientStop): void;


append(...elements: kendo.drawing.Element[]): void;


insert(position: number, element: kendo.drawing.Element): void;


remove(element: kendo.drawing.Element): void;


src(): string;


src(value: string): void;


rect(): kendo.geometry.Rect;


rect(value: kendo.geometry.Rect): void;


rect(rect: kendo.geometry.Rect): void;


reflow(): void;


end(): kendo.geometry.Point;


end(end: any): void;


end(end: kendo.geometry.Point): void;


start(): kendo.geometry.Point;


start(start: any): void;


start(start: kendo.geometry.Point): void;


close(): kendo.drawing.MultiPath;


curveTo(controlOut: any, controlIn: any, endPoint: any): kendo.drawing.MultiPath;


curveTo(controlOut: any, controlIn: any, endPoint: kendo.geometry.Point): kendo.drawing.MultiPath;


curveTo(controlOut: any, controlIn: kendo.geometry.Point, endPoint: any): kendo.drawing.MultiPath;


curveTo(controlOut: any, controlIn: kendo.geometry.Point, endPoint: kendo.geometry.Point): kendo.drawing.MultiPath;


curveTo(controlOut: kendo.geometry.Point, controlIn: any, endPoint: any): kendo.drawing.MultiPath;


curveTo(controlOut: kendo.geometry.Point, controlIn: any, endPoint: kendo.geometry.Point): kendo.drawing.MultiPath;


curveTo(controlOut: kendo.geometry.Point, controlIn: kendo.geometry.Point, endPoint: any): kendo.drawing.MultiPath;


curveTo(controlOut: kendo.geometry.Point, controlIn: kendo.geometry.Point, endPoint: kendo.geometry.Point): kendo.drawing.MultiPath;


fill(color: string, opacity?: number): kendo.drawing.MultiPath;


lineTo(x: number, y?: number): kendo.drawing.MultiPath;


lineTo(x: any, y?: number): kendo.drawing.MultiPath;


lineTo(x: kendo.geometry.Point, y?: number): kendo.drawing.MultiPath;


moveTo(x: number, y?: number): kendo.drawing.MultiPath;


moveTo(x: any, y?: number): kendo.drawing.MultiPath;


moveTo(x: kendo.geometry.Point, y?: number): kendo.drawing.MultiPath;


stroke(color: string, width?: number, opacity?: number): kendo.drawing.MultiPath;


get(field: string): any;


set(field: string, value: any): void;


static fromArc(arc: kendo.geometry.Arc, options?: any): kendo.drawing.Path;


static fromPoints(points: any, options?: any): kendo.drawing.Path;


static fromRect(rect: kendo.geometry.Rect, options?: any): kendo.drawing.Path;


static parse(svgPath: string, options?: any): kendo.drawing.MultiPath;


close(): kendo.drawing.Path;


curveTo(controlOut: any, controlIn: any, endPoint: any): kendo.drawing.Path;


curveTo(controlOut: any, controlIn: any, endPoint: kendo.geometry.Point): kendo.drawing.Path;


curveTo(controlOut: any, controlIn: kendo.geometry.Point, endPoint: any): kendo.drawing.Path;


curveTo(controlOut: any, controlIn: kendo.geometry.Point, endPoint: kendo.geometry.Point): kendo.drawing.Path;


curveTo(controlOut: kendo.geometry.Point, controlIn: any, endPoint: any): kendo.drawing.Path;


curveTo(controlOut: kendo.geometry.Point, controlIn: any, endPoint: kendo.geometry.Point): kendo.drawing.Path;


curveTo(controlOut: kendo.geometry.Point, controlIn: kendo.geometry.Point, endPoint: any): kendo.drawing.Path;


curveTo(controlOut: kendo.geometry.Point, controlIn: kendo.geometry.Point, endPoint: kendo.geometry.Point): kendo.drawing.Path;


fill(color: string, opacity?: number): kendo.drawing.Path;


lineTo(x: number, y?: number): kendo.drawing.Path;


lineTo(x: any, y?: number): kendo.drawing.Path;


lineTo(x: kendo.geometry.Point, y?: number): kendo.drawing.Path;


moveTo(x: number, y?: number): kendo.drawing.Path;


moveTo(x: any, y?: number): kendo.drawing.Path;


moveTo(x: kendo.geometry.Point, y?: number): kendo.drawing.Path;


stroke(color: string, width?: number, opacity?: number): kendo.drawing.Path;


center(): kendo.geometry.Point;


center(center: any): void;


center(center: kendo.geometry.Point): void;


radius(): number;


radius(value: number): void;


geometry(): kendo.geometry.Rect;


geometry(value: kendo.geometry.Rect): void;


fill(color: string, opacity?: number): kendo.drawing.Rect;


stroke(color: string, width?: number, opacity?: number): kendo.drawing.Rect;


anchor(): kendo.geometry.Point;


anchor(value: kendo.geometry.Point): void;


controlIn(): kendo.geometry.Point;


controlIn(value: kendo.geometry.Point): void;


controlOut(): kendo.geometry.Point;


controlOut(value: kendo.geometry.Point): void;


static create(element: JQuery, options?: any): kendo.drawing.Surface;


static create(element: Element, options?: any): kendo.drawing.Surface;


draw(element: kendo.drawing.Element): void;


eventTarget(e: any): kendo.drawing.Element;


hideTooltip(): void;


showTooltip(element: kendo.drawing.Element, options?: any): void;


content(value: string): void;


fill(color: string, opacity?: number): kendo.drawing.Text;


position(): kendo.geometry.Point;


position(value: kendo.geometry.Point): void;


stroke(color: string, width?: number, opacity?: number): kendo.drawing.Text;


bbox(matrix: kendo.geometry.Matrix): kendo.geometry.Rect;


getAnticlockwise(): boolean;


getCenter(): kendo.geometry.Point;


getEndAngle(): number;


getRadiusX(): number;


getRadiusY(): number;


getStartAngle(): number;


pointAt(angle: number): kendo.geometry.Point;


setAnticlockwise(value: boolean): kendo.geometry.Arc;


setCenter(value: kendo.geometry.Point): kendo.geometry.Arc;


setEndAngle(value: number): kendo.geometry.Arc;


setRadiusX(value: number): kendo.geometry.Arc;


setRadiusY(value: number): kendo.geometry.Arc;


setStartAngle(value: number): kendo.geometry.Arc;


clone(): kendo.geometry.Circle;


equals(other: kendo.geometry.Circle): boolean;


getRadius(): number;


setCenter(value: kendo.geometry.Point): kendo.geometry.Point;


setCenter(value: any): kendo.geometry.Point;


setRadius(value: number): kendo.geometry.Circle;


static rotate(angle: number, x: number, y: number): kendo.geometry.Matrix;


static scale(scaleX: number, scaleY: number): kendo.geometry.Matrix;


static translate(x: number, y: number): kendo.geometry.Matrix;


static unit(): kendo.geometry.Matrix;


clone(): kendo.geometry.Matrix;


equals(other: kendo.geometry.Matrix): boolean;


round(digits: number): kendo.geometry.Matrix;


multiplyCopy(matrix: kendo.geometry.Matrix): kendo.geometry.Matrix;


toArray(digits: number): any;


toString(digits: number, separator: string): string;


static create(x: number, y: number): kendo.geometry.Point;


static create(x: any, y: number): kendo.geometry.Point;


static create(x: kendo.geometry.Point, y: number): kendo.geometry.Point;


static min(): kendo.geometry.Point;


static max(): kendo.geometry.Point;


static minPoint(): kendo.geometry.Point;


static maxPoint(): kendo.geometry.Point;


clone(): kendo.geometry.Point;


distanceTo(point: kendo.geometry.Point): number;


equals(other: kendo.geometry.Point): boolean;


getX(): number;


getY(): number;


move(x: number, y: number): kendo.geometry.Point;


rotate(angle: number, center: kendo.geometry.Point): kendo.geometry.Point;


rotate(angle: number, center: any): kendo.geometry.Point;


round(digits: number): kendo.geometry.Point;


scale(scaleX: number, scaleY: number): kendo.geometry.Point;


scaleCopy(scaleX: number, scaleY: number): kendo.geometry.Point;


setX(value: number): kendo.geometry.Point;


setY(value: number): kendo.geometry.Point;


transform(tansformation: kendo.geometry.Transformation): kendo.geometry.Point;


transformCopy(tansformation: kendo.geometry.Transformation): kendo.geometry.Point;


translate(dx: number, dy: number): kendo.geometry.Point;


translateWith(vector: kendo.geometry.Point): kendo.geometry.Point;


translateWith(vector: any): kendo.geometry.Point;


static fromPoints(pointA: kendo.geometry.Point, pointB: kendo.geometry.Point): kendo.geometry.Rect;


static union(rectA: kendo.geometry.Rect, rectB: kendo.geometry.Rect): kendo.geometry.Rect;


bottomLeft(): kendo.geometry.Point;


bottomRight(): kendo.geometry.Point;


clone(): kendo.geometry.Rect;


equals(other: kendo.geometry.Rect): boolean;


getOrigin(): kendo.geometry.Point;


getSize(): kendo.geometry.Size;


height(): number;


setOrigin(value: kendo.geometry.Point): kendo.geometry.Rect;


setOrigin(value: any): kendo.geometry.Rect;


setSize(value: kendo.geometry.Size): kendo.geometry.Rect;


setSize(value: any): kendo.geometry.Rect;


topLeft(): kendo.geometry.Point;


topRight(): kendo.geometry.Point;


width(): number;


static create(width: number, height: number): kendo.geometry.Size;


static create(width: any, height: number): kendo.geometry.Size;


static create(width: kendo.geometry.Size, height: number): kendo.geometry.Size;


clone(): kendo.geometry.Size;


equals(other: kendo.geometry.Size): boolean;


getHeight(): number;


setWidth(value: number): kendo.geometry.Size;


setHeight(value: number): kendo.geometry.Size;


clone(): kendo.geometry.Transformation;


equals(other: kendo.geometry.Transformation): boolean;


matrix(): kendo.geometry.Matrix;


multiply(transformation: kendo.geometry.Transformation): kendo.geometry.Transformation;


rotate(angle: number, center: any): kendo.geometry.Transformation;


rotate(angle: number, center: kendo.geometry.Point): kendo.geometry.Transformation;


scale(scaleX: number, scaleY: number): kendo.geometry.Transformation;


translate(x: number, y: number): kendo.geometry.Transformation;


static extend(proto: Object): ArcGauge;


exportImage(options: any): JQueryPromise<any>;


exportPDF(options?: kendo.drawing.PDFOptions): JQueryPromise<any>;


exportSVG(options: any): JQueryPromise<any>;


svg(): void;


imageDataURL(): string;


value(): void;


static extend(proto: Object): Barcode;


svg(): string;


static extend(proto: Object): Chart;


findAxisByName(name: string): kendo.dataviz.ChartAxis;


findPaneByIndex(index: number): kendo.dataviz.ChartPane;


findPaneByName(name: string): kendo.dataviz.ChartPane;


findSeries(callback: Function): kendo.dataviz.ChartSeries;


findSeriesByIndex(index: number): kendo.dataviz.ChartSeries;


findSeriesByName(name: string): kendo.dataviz.ChartSeries;


getAxis(name: string): kendo.dataviz.ChartAxis;


plotArea(): kendo.dataviz.ChartPlotArea;


saveAsPDF(): void;


showTooltip(filter: Function): void;


showTooltip(filter: number): void;


showTooltip(filter: Date): void;


showTooltip(filter: string): void;


toggleHighlight(show: boolean, options: any): void;


static extend(proto: Object): Diagram;


addConnection(connection: any, undoable: boolean): void;


addShape(obj: any, undoable: boolean): kendo.dataviz.diagram.Shape;


alignShapes(direction: string): void;


boundingBox(items: any): kendo.dataviz.diagram.Rect;


bringIntoView(obj: any, options: any): void;


cancelEdit(): void;


connect(source: any, target: any, options: any): void;


connected(source: any, target: any): void;


copy(): void;


createConnection(item: any): void;


createShape(item: any): void;


cut(): void;


documentToModel(point: any): any;


documentToView(point: any): any;


edit(item: any): void;


getConnectionByModelId(id: string): kendo.dataviz.diagram.Connection;


getConnectionByModelId(id: number): kendo.dataviz.diagram.Connection;


getConnectionByModelUid(uid: string): kendo.dataviz.diagram.Connection;


getShapeById(id: string): any;


getShapeByModelId(id: string): kendo.dataviz.diagram.Shape;


getShapeByModelId(id: number): kendo.dataviz.diagram.Shape;


getShapeByModelUid(uid: string): kendo.dataviz.diagram.Shape;


layerToModel(point: any): any;


layout(options: any): void;


load(json: string): void;


modelToDocument(point: any): any;


modelToLayer(point: any): any;


modelToView(point: any): any;


pan(pan: any): void;


paste(): void;


redo(): void;


remove(items: any, undoable: boolean): void;


saveAsPdf(): JQueryPromise<any>;


saveEdit(): void;


select(): any;


select(elements: kendo.dataviz.diagram.Connection, options: any): void;


select(elements: kendo.dataviz.diagram.Shape, options: any): void;


select(elements: any, options: any): void;


selectAll(): void;


selectArea(rect: kendo.dataviz.diagram.Rect): void;


setConnectionsDataSource(dataSource: kendo.data.DataSource): void;


toBack(items: any, undoable: boolean): void;


toFront(items: any, undoable: boolean): void;


transformPoint(p: any): void;


transformRect(r: any): void;


undo(): void;


viewToDocument(point: kendo.dataviz.diagram.Point): kendo.dataviz.diagram.Point;


viewToModel(point: kendo.dataviz.diagram.Point): kendo.dataviz.diagram.Point;


viewport(): kendo.dataviz.diagram.Rect;


zoom(): number;


zoom(zoom: number, point: kendo.dataviz.diagram.Point): void;


static extend(proto: Object): LinearGauge;


allValues(values: any): any;


static extend(proto: Object): Map;


center(): kendo.dataviz.map.Location;


center(center: kendo.dataviz.map.Location): void;


eventOffset(e: any): kendo.geometry.Point;


eventOffset(e: JQueryEventObject): kendo.geometry.Point;


eventToLayer(e: any): kendo.geometry.Point;


eventToLayer(e: JQueryEventObject): kendo.geometry.Point;


eventToLocation(e: any): kendo.geometry.Point;


eventToLocation(e: JQueryEventObject): kendo.geometry.Point;


eventToView(e: any): kendo.geometry.Point;


eventToView(e: JQueryEventObject): kendo.geometry.Point;


extent(): kendo.dataviz.map.Extent;


extent(extent: kendo.dataviz.map.Extent): void;


layerToLocation(point: any, zoom: number): kendo.dataviz.map.Location;


layerToLocation(point: kendo.geometry.Point, zoom: number): kendo.dataviz.map.Location;


locationToLayer(location: any, zoom: number): kendo.geometry.Point;


locationToLayer(location: kendo.dataviz.map.Location, zoom: number): kendo.geometry.Point;


locationToView(location: any): kendo.geometry.Point;


locationToView(location: kendo.dataviz.map.Location): kendo.geometry.Point;


viewSize(): any;


viewToLocation(point: any, zoom: number): kendo.dataviz.map.Location;


viewToLocation(point: kendo.geometry.Point, zoom: number): kendo.dataviz.map.Location;


zoom(level: number): void;


static extend(proto: Object): QRCode;


value(options: string): void;


value(options: number): void;


static extend(proto: Object): RadialGauge;


allValues(values?: any): any;


static extend(proto: Object): Sparkline;


static extend(proto: Object): StockChart;


static extend(proto: Object): CircularGauge;


static extend(proto: Object): TreeMap;


imagerySet(): void;


static create(a: kendo.dataviz.map.Location, b?: kendo.dataviz.map.Location): kendo.dataviz.map.Extent;


static create(a: kendo.dataviz.map.Location, b?: any): kendo.dataviz.map.Extent;


static create(a: any, b?: kendo.dataviz.map.Location): kendo.dataviz.map.Extent;


static create(a: any, b?: any): kendo.dataviz.map.Extent;


contains(location: kendo.dataviz.map.Location): boolean;


containsAny(locations: any): boolean;


include(location: kendo.dataviz.map.Location): void;


includeAll(locations: any): void;


edges(): any;


toArray(): any;


overlaps(extent: kendo.dataviz.map.Extent): boolean;


static create(lat: number, lng?: number): kendo.dataviz.map.Location;


static create(lat: any, lng?: number): kendo.dataviz.map.Location;


static create(lat: kendo.dataviz.map.Location, lng?: number): kendo.dataviz.map.Location;


static fromLngLat(lnglat: any): kendo.dataviz.map.Location;


static fromLatLng(lnglat: any): kendo.dataviz.map.Location;


clone(): kendo.dataviz.map.Location;


destination(destination: kendo.dataviz.map.Location, bearing: number): number;


distanceTo(distance: number, bearing: number): kendo.dataviz.map.Location;


equals(location: kendo.dataviz.map.Location): boolean;


round(digits: number): kendo.dataviz.map.Location;


wrap(): kendo.dataviz.map.Location;


location(): kendo.dataviz.map.Location;


location(location: any): void;


location(location: kendo.dataviz.map.Location): void;


add(marker: kendo.dataviz.map.Marker): void;


remove(marker: kendo.dataviz.map.Marker): void;


setDataSource(): void;


slot(from: string, to?: string, limit?: boolean): kendo.geometry.Rect;


slot(from: string, to?: number, limit?: boolean): kendo.geometry.Rect;


slot(from: string, to?: Date, limit?: boolean): kendo.geometry.Rect;


slot(from: number, to?: string, limit?: boolean): kendo.geometry.Rect;


slot(from: number, to?: number, limit?: boolean): kendo.geometry.Rect;


slot(from: number, to?: Date, limit?: boolean): kendo.geometry.Rect;


slot(from: Date, to?: string, limit?: boolean): kendo.geometry.Rect;


slot(from: Date, to?: number, limit?: boolean): kendo.geometry.Rect;


slot(from: Date, to?: Date, limit?: boolean): kendo.geometry.Rect;


value(point: kendo.geometry.Point): void;


valueRange(): void;


series(): any;


data(): any;


data(data: any): void;


findPoint(callback: Function): kendo.dataviz.ChartPoint;


points(): any;


points(filter: Function): void;


toggleHighlight(show: boolean, filter: Function): void;


toggleHighlight(show: boolean, filter: any): void;


toggleVisibility(show: boolean, filter: Function): void;


position(offset: kendo.dataviz.diagram.Point): void;


rotate(angle: number, center: kendo.dataviz.diagram.Point): void;


source(): any;


source(source: kendo.dataviz.diagram.Shape): void;


source(source: kendo.dataviz.diagram.Point): void;


source(source: kendo.dataviz.diagram.Connector): void;


sourcePoint(): kendo.dataviz.diagram.Point;


target(): any;


target(target: kendo.dataviz.diagram.Shape): void;


target(target: kendo.dataviz.diagram.Point): void;


target(target: kendo.dataviz.diagram.Connector): void;


targetPoint(): kendo.dataviz.diagram.Point;


select(value: boolean): void;


type(): void;


type(value: string): void;


allPoints(): any;


redraw(options?: any): void;


position(): kendo.dataviz.diagram.Point;


append(element: any): void;


rect(): kendo.dataviz.diagram.Rect;


rect(rect: kendo.dataviz.diagram.Rect): void;


data(): string;


data(path: string): void;


points(points: any): void;


position(point: kendo.dataviz.diagram.Point): void;


clone(): kendo.dataviz.diagram.Shape;


connections(type: string): void;


getConnector(): void;


getPosition(side: string): void;


redraw(options: any): void;


redrawVisual(): void;


diff(): number;


equals(): boolean;


toHSV(): any;


toRGB(): any;


toBytes(): any;


toHex(): string;


toCss(): string;


toCssRgba(): string;


toDisplay(): string;


init(options: any): void;


background(): string;


background(value?: string): void;


bold(): boolean;


bold(value?: boolean): void;


borderBottom(): any;


borderBottom(value?: any): void;


borderLeft(): any;


borderLeft(value?: any): void;


borderRight(): any;


borderRight(value?: any): void;


borderTop(): any;


borderTop(value?: any): void;


color(): string;


color(value?: string): void;


comment(): string;


comment(value?: string): void;


clear(options?: any): void;


clearFilter(indices: any): void;


clearFilter(indices: number): void;


editor(): string;


editor(value?: string): void;


enable(): boolean;


enable(value?: boolean): void;


fillFrom(srcRange: Range, direction?: number): void;


fillFrom(srcRange: string, direction?: number): void;


filter(filter: boolean): void;


filter(filter: any): void;


fontFamily(): string;


fontFamily(value?: string): void;


fontSize(): number;


fontSize(value?: number): void;


forEachCell(callback: Function): void;


format(): string;


format(format?: string): void;


formula(): string;


formula(formula?: string): void;


hasFilter(): boolean;


input(): any;


input(value?: string): void;


input(value?: number): void;


input(value?: Date): void;


isSortable(): boolean;


isFilterable(): boolean;


italic(): boolean;


italic(value?: boolean): void;


link(): string;


link(url?: string): void;


merge(): void;


sort(sort: number): void;


sort(sort: any): void;


textAlign(): string;


textAlign(value?: string): void;


unmerge(): void;


values(values: any): void;


validation(): any;


validation(value?: any): void;


value(value?: string): void;


value(value?: number): void;


value(value?: Date): void;


verticalAlign(): string;


verticalAlign(value?: string): void;


wrap(): boolean;


wrap(value?: boolean): void;


clearFilter(indexes: number): void;


clearFilter(indexes: any): void;


columnWidth(): void;


columnWidth(index: number, width?: number): void;


batch(callback: Function, changeEventArgs: any): void;


deleteColumn(index: number): void;


deleteRow(index: number): void;


frozenColumns(): number;


frozenColumns(count?: number): void;


frozenRows(): number;


frozenRows(count?: number): void;


hideColumn(index: number): void;


hideRow(index: number): void;


insertColumn(index: number): void;


insertRow(index: number): void;


range(ref: string): kendo.spreadsheet.Range;


range(rowIndex: number, columnIndex: number, rowCount?: number, columnCount?: number): kendo.spreadsheet.Range;


rowHeight(): void;


rowHeight(index: number, width?: number): void;


selection(): kendo.spreadsheet.Range;


setDataSource(dataSource: kendo.data.DataSource, columns?: any): void;


showGridLines(): boolean;


showGridLines(showGridLines?: boolean): void;


toJSON(): void;


unhideColumn(index: number): void;


unhideRow(index: number): void;


deselect(): void;


getEnabled(): boolean;


getIndex(): number;


setPrevious(value: boolean): void;


getSelected(): boolean;


getSelectable(): boolean;


buttons(): any[];


resetButtons(): void;


open(target: JQuery, context: any): void;


static extend(proto: Object): BackButton;


badge(value: string): string;


badge(value: boolean): string;


static extend(proto: Object): Collapsible;


collapse(instant: boolean): void;


expand(instant?: boolean): void;


toggle(instant?: boolean): void;


static extend(proto: Object): DetailButton;


static extend(proto: Object): Layout;


append(dataItems: any): void;


prepend(dataItems: any): void;


replace(dataItems: any): void;


remove(dataItems: any): void;


setDataItem(item: JQuery, dataItem: kendo.data.Model): void;


static extend(proto: Object): ModalView;


open(target?: JQuery): void;


static extend(proto: Object): NavBar;


title(value: string): void;


static extend(proto: Object): Pane;


navigate(url: string, transition: string): void;


replace(url: string, transition: string): void;


static extend(proto: Object): PopOver;


open(target: JQuery): void;


value(dataItem: any): any;


static extend(proto: Object): Scroller;


animatedScrollTo(x: number, y: number): void;


contentResized(): void;


enable(): void;


pullHandled(): void;


scrollHeight(): void;


scrollTo(x: number, y: number): void;


scrollWidth(): void;


zoomOut(): void;


static extend(proto: Object): SplitView;


expandPanes(): void;


collapsePanes(): void;


badge(tab: string, value: string): string;


badge(tab: string, value: boolean): string;


badge(tab: number, value: string): string;


badge(tab: number, value: boolean): string;


currentItem(): JQuery;


switchTo(url: string): void;


switchTo(url: number): void;


switchByFullUrl(url: string): void;


static extend(proto: Object): View;


contentElement(): void;


toDataURL(): string;


toDataURLAsync(): JQueryPromise<any>;


append(element: kendo.drawing.Element): void;


export class Contact implements ContactInterface {
  id: String;
  public name: String;
  public country: String;
  public image: String;
  public state: String;
  public city: String;
  public address: String;
  public phone: String;
  public coordinates: Coords;

  constructor(public personId: String) { }

  dateNormalizer(date: string) {
    return date.substring(0, 10);
  }

  replacer(key: any, value: any) {
    if (key.indexOf('image') !== -1) {
      return undefined;
    }
    if (typeof value === 'string') {
      return value.trim();
    }
    return value;
  }

  public toJson() {
    const json = JSON.stringify(this, this.replacer);
    return json;
  }
}


/**
 * Created by Javier Fonseca <reivaj8904@gmail.com>
 on 23/01/2017.
 */
export interface ContactInterface {
  address?: String;
  image?: String;
}


dateNormalizer(date: string) {
    return date.substring(0, 10);
  }


replacer(key: any, value: any) {
    if (key.indexOf('image') !== -1) {
      return undefined;
    }
    if (typeof value === 'string') {
      return value.trim();
    }
    return value;
  }


public toJson() {
    const json = JSON.stringify(this, this.replacer);
    return json;
  }


() => srv.ngOnDestroy()


() => {
      TestBed.configureTestingModule({
        providers: [
          MenuService,
          { provide: ALAIN_I18N_TOKEN, useClass: AlainI18NServiceFake },
          { provide: ACLService, useClass: MockACLService },
        ],
      });
      srv = TestBed.inject<MenuService>(MenuService);
    }


() => {
      expect(srv).toBeTruthy();
    }


() => {
      srv.add(deepCopy(DATA));
      expect(srv.menus.length).toBe(DATA.length);
    }


() => {
      srv.add(deepCopy(DATA));
      let tick = 0;
      srv.resume(() => ++tick);
      expect(tick).toBeGreaterThan(0);
    }


() => ++tick


() => {
      srv.add(deepCopy(DATA));
      expect(srv.menus.length).toBe(DATA.length);
      srv.clear();
      expect(srv.menus.length).toBe(0);
    }


() => {
      const newMenus = [{ text: 'new menu' }, { text: 'new menu', hide: true }];
      srv.add(newMenus);
      expect(srv.menus[0]._hidden).toBe(false);
      expect(srv.menus[1]._hidden).toBe(true);
    }


() => {
      const newMenus = [{ text: 'new menu' }, { text: 'new menu', group: false }];
      srv.add(newMenus);
      expect(srv.menus[0].group).toBe(true);
      expect(srv.menus[1].group).toBe(false);
    }


() => {
      const newMenus = [{ text: 'new menu' }, { text: 'new menu', disabled: true }];
      srv.add(newMenus);
      expect(srv.menus[0].disabled).toBe(false);
      expect(srv.menus[1].disabled).toBe(true);
    }


() => {
      it('with url', () => {
        srv.add(deepCopy(DATA));
        srv.openedByUrl(`/dashboard/v1`);
        expect(srv.menus[0]._open).toBe(true);
      });
      it('not found', () => {
        srv.add(deepCopy(DATA));
        srv.openedByUrl(`/notfound`);
        expect(srv.menus.filter(w => w._open === false).length).toBe(srv.menus.length);
      });
      it('invalid url', () => {
        srv.add(deepCopy(DATA));
        srv.openedByUrl(null);
        expect(srv.menus.filter(w => w._open === false).length).toBe(0);
      });
      it('recursive up find', () => {
        srv.add(deepCopy(DATA));
        srv.openedByUrl(`/dashboard/v1/1`, true);
        expect(srv.menus[0]._open).toBe(true);
      });
    }


() => {
        srv.add(deepCopy(DATA));
        srv.openedByUrl(`/dashboard/v1`);
        expect(srv.menus[0]._open).toBe(true);
      }


() => {
        srv.add(deepCopy(DATA));
        srv.openedByUrl(`/notfound`);
        expect(srv.menus.filter(w => w._open === false).length).toBe(srv.menus.length);
      }


w => w._open === false


() => {
        srv.add(deepCopy(DATA));
        srv.openedByUrl(null);
        expect(srv.menus.filter(w => w._open === false).length).toBe(0);
      }


() => {
        srv.add(deepCopy(DATA));
        srv.openedByUrl(`/dashboard/v1/1`, true);
        expect(srv.menus[0]._open).toBe(true);
      }


() => {
      it('when recursive is false', () => {
        const item = srv.getHit(DATA, '/dashboard/invalid');
        expect(item == null).toBe(true);
      });
      it('when recursive is true', () => {
        const item = srv.getHit(DATA, '/dashboard/invalid', true);
        expect(item == null).toBe(false);
      });
      it('when include queryString', () => {
        expect(srv.getHit(DATA, '/test?a=1', true) != null).toBe(true);
      });
    }


() => {
        const item = srv.getHit(DATA, '/dashboard/invalid');
        expect(item == null).toBe(true);
      }


() => {
        const item = srv.getHit(DATA, '/dashboard/invalid', true);
        expect(item == null).toBe(false);
      }


() => {
        expect(srv.getHit(DATA, '/test?a=1', true) != null).toBe(true);
      }


() => {
      it('with url', () => {
        srv.add(deepCopy(DATA));
        const menus = srv.getPathByUrl(`/dashboard/v1`);
        expect(menus.length).toBe(2);
        expect(menus[0].text).toBe('dashboard');
      });
      it('invalid url', () => {
        srv.add(deepCopy(DATA));
        const menus = srv.getPathByUrl(`/dashboard/v1111`);
        expect(menus.length).toBe(0);
      });
      it('recursive up find', () => {
        srv.add(deepCopy(DATA));
        expect(srv.getPathByUrl(`/dashboard/1`).length).toBe(0);
        expect(srv.getPathByUrl(`/dashboard/1`, true).length).toBe(1);
      });
    }


() => {
        srv.add(deepCopy(DATA));
        const menus = srv.getPathByUrl(`/dashboard/v1`);
        expect(menus.length).toBe(2);
        expect(menus[0].text).toBe('dashboard');
      }


() => {
        srv.add(deepCopy(DATA));
        const menus = srv.getPathByUrl(`/dashboard/v1111`);
        expect(menus.length).toBe(0);
      }


() => {
        srv.add(deepCopy(DATA));
        expect(srv.getPathByUrl(`/dashboard/1`).length).toBe(0);
        expect(srv.getPathByUrl(`/dashboard/1`, true).length).toBe(1);
      }


() => {
      it('should be under the dashboard', () => {
        srv.add(deepCopy(DATA));
        expect(srv.menus[0].children![1].children!.length).toBe(1);
      });
      it('should be use [shortcutRoot: true]', () => {
        const newMenus = [
          {
            text: 'new menu',
            children: [
              { text: 'submenu1', link: '/' },
              { text: 'submenu2', link: '/' },
              { text: 'sc', shortcutRoot: true },
            ],
          },
          {
            text: 'text',
            children: [{ text: 'sub text', link: '/text/sub', shortcut: true }],
          },
        ] as Menu[];
        srv.add(newMenus);
        expect(srv.menus[0].children![2].children!.length).toBe(1);
      });
      it('should be under zero node', () => {
        const newMenus = [
          {
            text: 'new menu',
            i18n: 'test',
          },
          {
            text: 'text',
            children: [{ text: 'sub text', link: '/text/sub', shortcut: true }],
          },
        ] as Menu[];
        srv.add(newMenus);
        expect(srv.menus[0].children![0].children!.length).toBe(1);
      });
      it('should be clean children', () => {
        const newMenus = [
          {
            text: 'new menu',
            children: [
              { text: 'submenu1', link: '/' },
              { text: 'submenu2', link: '/' },
              { text: 'sc', shortcutRoot: true },
            ],
          },
          {
            text: 'text',
            children: [{ text: 'sub text', link: '/text/sub', shortcut: true }],
          },
        ] as Menu[];
        srv.add(newMenus);
        const shortcutList = srv.menus[0].children![2].children;
        expect(shortcutList!.length).toBe(1);
        expect(shortcutList![0].__parent).toBe(srv.menus[0].children![2]);
      });
    }


() => {
        srv.add(deepCopy(DATA));
        expect(srv.menus[0].children![1].children!.length).toBe(1);
      }


() => {
        const newMenus = [
          {
            text: 'new menu',
            children: [
              { text: 'submenu1', link: '/' },
              { text: 'submenu2', link: '/' },
              { text: 'sc', shortcutRoot: true },
            ],
          },
          {
            text: 'text',
            children: [{ text: 'sub text', link: '/text/sub', shortcut: true }],
          },
        ] as Menu[];
        srv.add(newMenus);
        expect(srv.menus[0].children![2].children!.length).toBe(1);
      }


() => {
        const newMenus = [
          {
            text: 'new menu',
            i18n: 'test',
          },
          {
            text: 'text',
            children: [{ text: 'sub text', link: '/text/sub', shortcut: true }],
          },
        ] as Menu[];
        srv.add(newMenus);
        expect(srv.menus[0].children![0].children!.length).toBe(1);
      }


() => {
        const newMenus = [
          {
            text: 'new menu',
            children: [
              { text: 'submenu1', link: '/' },
              { text: 'submenu2', link: '/' },
              { text: 'sc', shortcutRoot: true },
            ],
          },
          {
            text: 'text',
            children: [{ text: 'sub text', link: '/text/sub', shortcut: true }],
          },
        ] as Menu[];
        srv.add(newMenus);
        const shortcutList = srv.menus[0].children![2].children;
        expect(shortcutList!.length).toBe(1);
        expect(shortcutList![0].__parent).toBe(srv.menus[0].children![2]);
      }


() => {
      const newMenus = [
        { text: 'new menu', acl: 'admin' },
        { text: 'new menu', acl: 'user' },
      ];
      srv.add(newMenus);
      expect(srv.menus[0]._aclResult).toBe(true);
      expect(srv.menus[1]._aclResult).toBe(false);
    }


(done: () => void) => {
      const newMenus = [{ text: 'new menu' }];
      srv.change.pipe(filter(ls => ls.length > 0)).subscribe(res => {
        expect(res.length).toBe(1);
        expect(res[0].text).toBe(newMenus[0].text);
        done();
      });
      srv.add(newMenus);
    }


ls => ls.length > 0


res => {
        expect(res.length).toBe(1);
        expect(res[0].text).toBe(newMenus[0].text);
        done();
      }


() => {
      const newMenus = [{ text: 'new menu', key: 'a' }, { text: 'new menu' }];
      srv.add(newMenus);
      expect(srv.getItem('a') == null).toBe(false);
      expect(srv.getItem('invalid-key') == null).toBe(true);
    }


() => {
      it('should be working', () => {
        const newMenus = [{ text: 'a', key: 'a' }];
        srv.add(newMenus);
        expect(srv.getItem('a')!.text).toBe('a');
        srv.setItem('a', { text: 'b', badge: 10 });
        expect(srv.getItem('a')!.text).toBe('b');
        expect(srv.getItem('a')!.badge).toBe(10);
      });
      it('should be ingore update when not found key', () => {
        const newMenus = [{ text: 'a', key: 'a' }];
        srv.add(newMenus);
        srv.setItem('invalid-key', { text: 'b' });
        expect(srv.getItem('a')!.text).toBe('a');
      });
    }


() => {
        const newMenus = [{ text: 'a', key: 'a' }];
        srv.add(newMenus);
        expect(srv.getItem('a')!.text).toBe('a');
        srv.setItem('a', { text: 'b', badge: 10 });
        expect(srv.getItem('a')!.text).toBe('b');
        expect(srv.getItem('a')!.badge).toBe(10);
      }


() => {
        const newMenus = [{ text: 'a', key: 'a' }];
        srv.add(newMenus);
        srv.setItem('invalid-key', { text: 'b' });
        expect(srv.getItem('a')!.text).toBe('a');
      }


() => {
      it('ng-alain #107', () => {
        srv.add(deepCopy(DATA));
        expect(srv.menus[0].children!.filter(w => w.shortcutRoot === true).length).toBe(1);
        expect(srv.menus[0].children![1].children!.length).toBe(1);
        srv.resume();
        expect(srv.menus[0].children!.filter(w => w.shortcutRoot === true).length).toBe(1);
        expect(srv.menus[0].children![1].children!.length).toBe(1);
      });
    }


() => {
        srv.add(deepCopy(DATA));
        expect(srv.menus[0].children!.filter(w => w.shortcutRoot === true).length).toBe(1);
        expect(srv.menus[0].children![1].children!.length).toBe(1);
        srv.resume();
        expect(srv.menus[0].children!.filter(w => w.shortcutRoot === true).length).toBe(1);
        expect(srv.menus[0].children![1].children!.length).toBe(1);
      }


w => w.shortcutRoot === true


() => {
      it('should be null', () => {
        srv.add([
          {
            text: 'dashboard',
            link: '/dashboard',
            icon: null,
          },
        ]);
        const icon: any = srv.menus[0].icon;
        expect(icon).toBeNull();
      });
      it('should be undefined', () => {
        srv.add([
          {
            text: 'dashboard',
            link: '/dashboard',
            icon: undefined,
          },
        ]);
        const icon: any = srv.menus[0].icon;
        expect(icon).toBeUndefined();
      });
      it('should be type is string', () => {
        srv.add([
          {
            text: 'dashboard',
            link: '/dashboard',
            icon: 'aa',
          },
        ]);
        const icon: any = srv.menus[0].icon;
        expect(typeof icon).toBe('object');
        expect(icon.type).toBe('class');
      });
      it('should be type is object', () => {
        srv.add([
          {
            text: 'dashboard',
            link: '/dashboard',
            icon: { type: 'icon', value: 'user' },
          },
        ]);
        const icon: any = srv.menus[0].icon;
        expect(typeof icon).toBe('object');
        expect(icon.type).toBe('icon');
      });
      it('should be anticon anticon-user', () => {
        srv.add([
          {
            text: 'dashboard',
            link: '/dashboard',
            icon: `anticon anticon-user`,
          },
        ]);
        const icon: any = srv.menus[0].icon;
        expect(typeof icon).toBe('object');
        expect(icon.type).toBe('icon');
        expect(icon.value).toBe('user');
      });
      it('should be image', () => {
        srv.add([
          {
            text: 'dashboard',
            link: '/dashboard',
            icon: `http://ng-alain.com/1.jpg`,
          },
        ]);
        const icon: any = srv.menus[0].icon;
        expect(typeof icon).toBe('object');
        expect(icon.type).toBe('img');
      });
    }


() => {
        srv.add([
          {
            text: 'dashboard',
            link: '/dashboard',
            icon: null,
          },
        ]);
        const icon: any = srv.menus[0].icon;
        expect(icon).toBeNull();
      }


() => {
        srv.add([
          {
            text: 'dashboard',
            link: '/dashboard',
            icon: undefined,
          },
        ]);
        const icon: any = srv.menus[0].icon;
        expect(icon).toBeUndefined();
      }


() => {
        srv.add([
          {
            text: 'dashboard',
            link: '/dashboard',
            icon: 'aa',
          },
        ]);
        const icon: any = srv.menus[0].icon;
        expect(typeof icon).toBe('object');
        expect(icon.type).toBe('class');
      }


() => {
        srv.add([
          {
            text: 'dashboard',
            link: '/dashboard',
            icon: { type: 'icon', value: 'user' },
          },
        ]);
        const icon: any = srv.menus[0].icon;
        expect(typeof icon).toBe('object');
        expect(icon.type).toBe('icon');
      }


() => {
        srv.add([
          {
            text: 'dashboard',
            link: '/dashboard',
            icon: `anticon anticon-user`,
          },
        ]);
        const icon: any = srv.menus[0].icon;
        expect(typeof icon).toBe('object');
        expect(icon.type).toBe('icon');
        expect(icon.value).toBe('user');
      }


() => {
        srv.add([
          {
            text: 'dashboard',
            link: '/dashboard',
            icon: `http://ng-alain.com/1.jpg`,
          },
        ]);
        const icon: any = srv.menus[0].icon;
        expect(typeof icon).toBe('object');
        expect(icon.type).toBe('img');
      }


() => {
    it('with ALAIN_I18N_TOKEN', () => {
      TestBed.configureTestingModule({
        providers: [
          MenuService,
          { provide: ALAIN_I18N_TOKEN, useClass: AlainI18NServiceFake },
          { provide: ACLService, useClass: MockACLService },
        ],
      });
      srv = TestBed.inject<MenuService>(MenuService);
      spyOn(srv, 'resume');
      expect(srv.resume).not.toHaveBeenCalled();
      TestBed.inject(ALAIN_I18N_TOKEN).use('en');
      expect(srv.resume).toHaveBeenCalled();
    });

    it('without ALAIN_I18N_TOKEN', () => {
      TestBed.configureTestingModule({
        providers: [MenuService, { provide: ACLService, useClass: MockACLService }],
      });
      srv = TestBed.inject<MenuService>(MenuService);
      expect(true).toBe(true);
    });
  }


() => {
      TestBed.configureTestingModule({
        providers: [
          MenuService,
          { provide: ALAIN_I18N_TOKEN, useClass: AlainI18NServiceFake },
          { provide: ACLService, useClass: MockACLService },
        ],
      });
      srv = TestBed.inject<MenuService>(MenuService);
      spyOn(srv, 'resume');
      expect(srv.resume).not.toHaveBeenCalled();
      TestBed.inject(ALAIN_I18N_TOKEN).use('en');
      expect(srv.resume).toHaveBeenCalled();
    }


() => {
      TestBed.configureTestingModule({
        providers: [MenuService, { provide: ACLService, useClass: MockACLService }],
      });
      srv = TestBed.inject<MenuService>(MenuService);
      expect(true).toBe(true);
    }


class MockACLService {
  can(val: string) {
    return val === 'admin';
  }
}


can(val: string) {
    return val === 'admin';
  }


(props) => {
  const localStore = useLocalStore<IndexPageStore>();

  return (
    <LoadingIndicator isActive={localStore.isRequesting}>
      <MainOverview />
      <Divider horizontal={true}>
        <Header as="h4">
          <Icon name="users" /> Actors
        </Header>
      </Divider>
      <Actors />
    </LoadingIndicator>


interface IProps {}


(t) => `1px solid ${t?.colors?.borders}`


(t) => t?.colors?.choggleBox


(t) => t?.colors?.link


(t) => t?.colors?.gray


(t: MyTheme) => `1px solid ${t.codeColor.border}`


(t: MyTheme) => t.codeColor.blue


(t: MyTheme) => t.codeColor.gray


(t: MyTheme) => t.codeColor.orange


(t: MyTheme) => t.codeColor.green


interface MyTheme extends Theme {
  codeColor: {
    [x: string]: string;
  };
}


export declare class ScopeData {
    readonly path: (string | number)[];
    readonly allData: TemplateData;
    constructor(data: TemplateData);
    getScopeData<T extends TemplateContent | TemplateData[]>(): T;
}


getScopeData<T extends TemplateContent | TemplateData[]>(): T;


export function SortOption<T>({
  label,
  value: sort,
  asc,
  desc,
  defaultOrder = 'ASC',
  default: defaultVal = false,
}: SortOptionProps<T>) {
  const classes = useStyles();
  const ascNode = asc ? (
    <ActualSortOption
      order="ASC"
      label={asc}
      sort={sort}
      defaultOrder={defaultOrder}
      default={defaultVal && defaultOrder === 'ASC'}
    />
  ) : null;
  const descNode = desc ? (
    <ActualSortOption
      order="DESC"
      label={desc}
      sort={sort}
      defaultOrder={defaultOrder}
      default={defaultVal && defaultOrder === 'DESC'}
    />
  ) : null;
  return (
    <>
      <FormLabel className={classes.label}>{label}</FormLabel>
      {defaultOrder === 'ASC' ? (
        <>
          {ascNode}
          {descNode}
        </>
      ) : (
        <>
          {descNode}
          {ascNode}
        </>
      )}
    </>
  );
}


function ActualSortOption<T>({
  order,
  label,
  sort,
  defaultOrder,
  default: defaultVal,
}: {
  order: Order;
  label: React.ReactNode;
  sort: keyof T;
  defaultOrder: Order;
  default: boolean;
}) {
  const { value, onChange } = useRadioGroup()!;
  return (
    <FormControlLabel
      label={label}
      onChange={() => {
        // Ignore types and fake event to send to RadioGroup which will convert
        // it back to SortValue. This is so we don't have to use our own context
        // to pass onChange callback from SortControl down to SortOptions.
        onChange?.(
          {
            target: {
              value: defaultVal
                ? {}
                : {
                    sort,
                    order,
                  },
            },
          } as any,
          ''
        );
      }}


({ typography, spacing }) => ({
  label: {
    fontWeight: typography.weight.bold,
    margin: spacing(2, 0, 1),
  },
})


export interface SortOptionProps<T> {
  label: ReactNode;
  value: keyof T;
  asc?: ReactNode;
  desc?: ReactNode;
  defaultOrder?: Order;
  default?: boolean;
}


/**
 * Given a design token name, return a new FAST CSSDesignToken.
 *
 * @remarks A VS Code theme CSS variable can be optionally passed to be
 * associated with the design token.
 *
 * @remarks On the first execution the VS Code theme listener will also be
 * initialized.
 *
 * @param name A design token name.
 * @param vscodeThemeVar A VS Code theme CSS variable name to be associated with
 * the design token.
 * @returns A FAST CSSDesignToken that emits a CSS custom property.
 */
export declare function create<T>(name: string, vscodeThemeVar?: string): CSSDesignToken<T>;


/**
 * The possible CSSDesignToken generic types.
 */
export declare type T = string | number | boolean | symbol | any[] | Uint8Array | ({
    createCSS?(): string;
} & Record<PropertyKey, any>) | null;


(coordinate: Coordinate) => {
        this.factorySite.latitude = coordinate.latitude;
        this.factorySite.longitude = coordinate.longitude;
        this.defaultLatitude = coordinate.latitude;
        this.defaultLongitude = coordinate.longitude;
      }


@Component({
  selector: 'app-factory-site-map',
  templateUrl: './factory-site-map.component.html',
  styleUrls: ['./factory-site-map.component.scss']
})

export class FactorySiteMapComponent implements OnInit, OnChanges {

  @Input()
  factorySites: FactorySite[];
  @Input()
  factorySite: FactorySite;
  @Input()
  modalMode = false;

  mapType = 'terrain';

  companyId: ID;
  @Output() selectedFactorySite = new EventEmitter<ID>();

  styles =
    [
      {
        featureType: 'water',
        elementType: 'geometry.fill',
        stylers: [
          {
            color: '#d3d3d3'
          }
        ]
      },
      {
        featureType: 'transit',
        stylers: [
          {
            color: '#808080'
          },
          {
            visibility: 'off'
          }
        ]
      },
      {
        featureType: 'road.highway',
        elementType: 'geometry.stroke',
        stylers: [
          {
            visibility: 'on'
          },
          {
            color: '#b3b3b3'
          }
        ]
      },
      {
        featureType: 'road.highway',
        elementType: 'geometry.fill',
        stylers: [
          {
            color: '#ffffff'
          }
        ]
      },
      {
        featureType: 'road.local',
        elementType: 'geometry.fill',
        stylers: [
          {
            visibility: 'on'
          },
          {
            color: '#ffffff'
          },
          {
            weight: 1.8
          }
        ]
      },
      {
        featureType: 'road.local',
        elementType: 'geometry.stroke',
        stylers: [
          {
            color: '#d7d7d7'
          }
        ]
      },
      {
        featureType: 'poi',
        elementType: 'geometry.fill',
        stylers: [
          {
            visibility: 'on'
          },
          {
            color: '#ebebeb'
          }
        ]
      },
      {
        featureType: 'administrative',
        elementType: 'geometry',
        stylers: [
          {
            color: '#a7a7a7'
          }
        ]
      },
      {
        featureType: 'road.arterial',
        elementType: 'geometry.fill',
        stylers: [
          {
            color: '#ffffff'
          }
        ]
      },
      {
        featureType: 'road.arterial',
        elementType: 'geometry.fill',
        stylers: [
          {
            color: '#ffffff'
          }
        ]
      },
      {
        featureType: 'landscape',
        elementType: 'geometry.fill',
        stylers: [
          {
            visibility: 'on'
          },
          {
            color: '#efefef'
          }
        ]
      },
      {
        featureType: 'road',
        elementType: 'labels.text.fill',
        stylers: [
          {
            color: '#696969'
          }
        ]
      },
      {
        featureType: 'administrative',
        elementType: 'labels.text.fill',
        stylers: [
          {
            visibility: 'on'
          },
          {
            color: '#737373'
          }
        ]
      },
      {
        featureType: 'poi',
        elementType: 'labels.icon',
        stylers: [
          {
            visibility: 'off'
          }
        ]
      },
      {
        featureType: 'poi',
        elementType: 'labels',
        stylers: [
          {
            visibility: 'off'
          }
        ]
      },
      {
        featureType: 'road.arterial',
        elementType: 'geometry.stroke',
        stylers: [
          {
            color: '#d6d6d6'
          }
        ]
      },
      {
        featureType: 'road',
        elementType: 'labels.icon',
        stylers: [
          {
            visibility: 'off'
          }
        ]
      },
      { },
      {
        featureType: 'poi',
        elementType: 'geometry.fill',
        stylers: [
          {
            color: '#dadada'
          }
        ]
      }
    ];

  @ViewChild('AgmMap', { static: true })
  agmMap: AgmMap;
  defaultLatitude = 50;
  defaultLongitude = 10;
  height = 330;
  zoom = 5;

  constructor(
    private route: ActivatedRoute,
    private router: Router,
    private geocoderService: GeocoderService) { }

  ngOnInit(): void {
    if (this.modalMode) {
      this.zoom = 7;
      this.height = 460;
      this.defaultLatitude = 48.5;
    }
  }

  navigateToFactorySite(id: ID): void {
    this.router.navigate([id], { relativeTo: this.route });
  }

  ngOnChanges(changes: SimpleChanges): void {
    if (this.modalMode && changes.factorySite && (this.factorySite.zip || this.factorySite.city)) {
      this.placeMarkerForFactorySite(this.factorySite);
    }
  }

  placeMarkerForFactorySite(factorySite: FactorySite) {
    this.geocoderService.getGeocode(factorySite.line1,
          factorySite.zip,
          factorySite.city,
          factorySite.country.name,
      (coordinate: Coordinate) => {
        this.factorySite.latitude = coordinate.latitude;
        this.factorySite.longitude = coordinate.longitude;
        this.defaultLatitude = coordinate.latitude;
        this.defaultLongitude = coordinate.longitude;
      });
  }

}


ngOnInit(): void {
    if (this.modalMode) {
      this.zoom = 7;
      this.height = 460;
      this.defaultLatitude = 48.5;
    }
  }


navigateToFactorySite(id: ID): void {
    this.router.navigate([id], { relativeTo: this.route });
  }


ngOnChanges(changes: SimpleChanges): void {
    if (this.modalMode && changes.factorySite && (this.factorySite.zip || this.factorySite.city)) {
      this.placeMarkerForFactorySite(this.factorySite);
    }
  }


placeMarkerForFactorySite(factorySite: FactorySite) {
    this.geocoderService.getGeocode(factorySite.line1,
          factorySite.zip,
          factorySite.city,
          factorySite.country.name,
      (coordinate: Coordinate) => {
        this.factorySite.latitude = coordinate.latitude;
        this.factorySite.longitude = coordinate.longitude;
        this.defaultLatitude = coordinate.latitude;
        this.defaultLongitude = coordinate.longitude;
      });
  }


export function optional<RT extends Any>(type: RT, name?: string): OptionalTypeC<RT> {
  return new OptionalTypeC(type, name)
}


(base: Any): string => `optional ${base.name}`