function culture(): {
        name: string;
        calendar: {
            AM: string[];
            PM: string[];
            "/": string;
            ":": string;
            days: {
                names: string[];
                namesAbbr: string[];
                namesShort: string[];
            };
            months: {
                names: string[];
                namesAbbr: string[];
            };
            patterns: {
                D: string;
                F: string;
                G: string;
                M: string;
                T: string;
                Y: string;
                d: string;
                g: string;
                m: string;
                s: string;
                t: string;
                u: string;
                y: string;
            };
            firstDay: number;
            twoDigitYearMax: number;
        };
        calendars: {
            standard: {
                AM: string[];
                PM: string[];
                "/": string;
                ":": string;
                days: {
                    names: string[];
                    namesAbbr: string[];
                    namesShort: string[];
                };
                months: {
                    names: string[];
                    namesAbbr: string[];
                };
                patterns: {
                    D: string;
                    F: string;
                    G: string;
                    M: string;
                    T: string;
                    Y: string;
                    d: string;
                    g: string;
                    m: string;
                    s: string;
                    t: string;
                    u: string;
                    y: string;
                };
                firstDay: string;
                twoDigitYearMax: number;
            };
        };
        numberFormat: {
            currency: {
                decimals: number;
                ",": string;
                ".": string;
                groupSize: number[];
                pattern: string[];
                symbol: string;
            };
            decimals: number;
            ",": string;
            ".": string;
            groupSize: number[];
            pattern: string[];
            percent: {
                decimals: number;
                ",": string;
                ".": string;
                groupSize: number[];
                pattern: string[];
                symbol: string;
            };
        };
    };


function format(format: string, ...values: any[]): string;


function fx(selector: string): effects.Element;


function fx(element: Element): effects.Element;


function fx(element: JQuery): effects.Element;


function init(selector: string, ...namespaces: any[]): void;


function init(element: JQuery, ...namespaces: any[]): void;


function init(element: Element, ...namespaces: any[]): void;


function observable(data: any): kendo.data.ObservableObject;


function observableHierarchy(array: any[]): kendo.data.ObservableArray;


function render(template: (data: any) => string, data: any[]): string;


function template(template: string, options?: TemplateOptions): (data: any) => string;


function guid(): string;


function notify(widget: typeof kendo.ui.Widget, namespace?: typeof kendo.ui): void;


function notify(widget: typeof kendo.ui.Widget, namespace?: typeof kendo.mobile.ui): void;


function notify(widget: typeof kendo.ui.Widget, namespace?: typeof kendo.dataviz.ui): void;


function widgetInstance(element: JQuery, suite?: typeof kendo.ui): kendo.ui.Widget;


function widgetInstance(element: JQuery, suite?: typeof kendo.mobile.ui): kendo.ui.Widget;


function widgetInstance(element: JQuery, suite?: typeof kendo.dataviz.ui): kendo.ui.Widget;


function enable(): void;


function disable(): void;


function dataSourceBinding(bindingName: String, fieldName: String, setter: String): DataSourceBinder;


function source(bindingName: String, fieldName: String, setter: String): DataSourceBinder;


function dependencies(bindingName: String, fieldName: String, setter: String): DataSourceBinder;


function progress(container: JQuery, toggle: boolean): void;


function plugin(widget: typeof kendo.ui.Widget, register?: typeof kendo.ui, prefix?: String): void;


function plugin(widget: any, register?: typeof kendo.ui, prefix?: String): void;


function plugin(widget: typeof kendo.ui.Widget, register?: typeof kendo.mobile.ui, prefix?: String): void;


function plugin(widget: any, register?: typeof kendo.mobile.ui, prefix?: String): void;


function plugin(widget: typeof kendo.ui.Widget, register?: typeof kendo.dataviz.ui, prefix?: String): void;


function plugin(widget: any, register?: typeof kendo.dataviz.ui, prefix?: String): void;


function init(selector: string): void;


function init(element: JQuery): void;


function init(element: Element): void;


function registerTheme(name: string, options: any): void;


function plugin(widget: typeof kendo.ui.Widget): void;


function plugin(widget: any): void;


function saveAs(group: kendo.drawing.Group, fileName: string,
                    proxyUrl?: string, callback?: Function): void;


function setDayOfWeek(targetDate: Date, dayOfWeek: number, direction: number): void;


function dayOfWeek(targetDate: Date, dayOfWeek: number, direction: number): Date;


function weekInYear(date: Date, weekStart?: number): number;


function getDate(date: Date): Date;


function isInDateRange(targetDate: Date, lowerLimitDate: Date, upperLimitDate: Date): boolean;


function isInTimeRange(targetDate: Date, lowerLimitDate: Date, upperLimitDate: Date): boolean;


function isToday(targetDate: Date): boolean;


function nextDay(targetDate: Date): Date;


function previousDay(targetDate: Date): Date;


function toUtcTime(targetDate: Date): number;


function setTime(targetDate: Date, millisecondsToAdd: number, ignoreDST: boolean): void;


function setHours(targetDate: Date, sourceDate: number): Date;


function addDays(targetDate: Date, numberOfDaysToAdd: number): Date;


function today(): Date;


function toInvariantTime(targetDate: Date): Date;


function firstDayOfMonth(targetDate: Date): Date;


function lastDayOfMonth(targetDate: Date): Date;


function getMilliseconds(targetDate: Date): number;


function align(elements: any, rect: kendo.geometry.Rect, alignment: string): void;


function drawDOM(element: JQuery, options: any): JQueryPromise<any>;


function exportImage(group: kendo.drawing.Group, options?: any): JQueryPromise<any>;


function exportPDF(group: kendo.drawing.Group, options?: kendo.drawing.PDFOptions): JQueryPromise<any>;


function exportSVG(group: kendo.drawing.Group, options?: any): JQueryPromise<any>;


function fit(element: kendo.drawing.Element, rect: kendo.geometry.Rect): void;


function stack(elements: any): void;


function vAlign(elements: any, rect: kendo.geometry.Rect, alignment: string): void;


function vStack(elements: any): void;


function vWrap(elements: any, rect: kendo.geometry.Rect): any;


function wrap(elements: any, rect: kendo.geometry.Rect): any;


function box(element: HTMLElement): any;


function fillScale(firstElement: HTMLElement, secondElement: HTMLElement): number;


function fitScale(firstElement: HTMLElement, secondElement: HTMLElement): number;


function transformOrigin(firstElement: HTMLElement, secondElement: HTMLElement): any;


function alert(text: string): void;


function antiForgeryTokens(): any;


function bind(element: string, viewModel: any, namespace?: any): void;


function bind(element: string, viewModel: kendo.data.ObservableObject, namespace?: any): void;


function bind(element: JQuery, viewModel: any, namespace?: any): void;


function bind(element: JQuery, viewModel: kendo.data.ObservableObject, namespace?: any): void;


function bind(element: Element, viewModel: any, namespace?: any): void;


function bind(element: Element, viewModel: kendo.data.ObservableObject, namespace?: any): void;


function confirm(text: string): JQueryPromise<any>;


function culture(culture: string): void;


function destroy(element: string): void;


function destroy(element: JQuery): void;


function destroy(element: Element): void;


function htmlEncode(value: string): string;


function observableHierarchy(array: any): void;


function observableFileManagerData(array: any): void;


function parseDate(value: string, formats?: string, culture?: string): Date | null;


function parseDate(value: string, formats?: any, culture?: string): Date | null;


function parseExactDate(value: string, formats?: string, culture?: string): Date | null;


function parseExactDate(value: string, formats?: any, culture?: string): Date| null;


function parseFloat(value: string, culture?: string): number;


function parseInt(value: string, culture?: string): number;


function parseColor(color: string, noerror: boolean): kendo.Color;


function prompt(text: string, defaultValue: string): JQueryPromise<any>;


function proxyModelSetters(): void;


function proxyModelSetters(data: kendo.data.Model): void;


function resize(element: string, force: boolean): void;


function resize(element: JQuery, force: boolean): void;


function resize(element: Element, force: boolean): void;


function saveAs(options: any): void;


function stringify(value: any): string;


function throttle(fn: Function, timeout: number): Function;


function touchScroller(element: string): void;


function touchScroller(element: JQuery): void;


function touchScroller(element: Element): void;


function toString(value: Date, format: string, culture?: string): string;


function toString(value: number, format: string, culture?: string): string;


function unbind(element: string): void;


function unbind(element: JQuery): void;


function unbind(element: Element): void;


function defineFont(map: any): void;


function offset(utcTime: Date, timezone: string): number;


function offset(utcTime: number, timezone: string): number;


function convert(targetDate: Date, fromOffset: number, toOffset: number): Date;


function convert(targetDate: Date, fromOffset: number, toOffset: string): Date;


function convert(targetDate: Date, fromOffset: string, toOffset: number): Date;


function convert(targetDate: Date, fromOffset: string, toOffset: string): Date;


function apply(targetDate: Date, offset: number): Date;


function apply(targetDate: Date, offset: string): Date;


function remove(targetDate: Date, offset: number): Date;


function remove(targetDate: Date, offset: string): Date;


function abbr(targetDate: Date, timezone: string): string;


function toLocalDate(targetDate: Date): Date;


function toLocalDate(targetDate: number): Date;


function defineFunction(name: String, handler: Function): any;


class Class {
        static fn: Class;
        static extend(prototype: Object): Class;
    }


class Observable extends Class {
        static fn: Observable;
        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;
    }


class UserEvents extends Observable {
        static defaultThreshold(value: number): void;
        static minHold(value: number): void;

        init(...args: any[]): void;
        preventIfMoving(e?: any): void;
        destroy(): 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;
    }


class View extends Observable {
        constructor(element: Element, options?: ViewOptions);
        constructor(element: string, options?: ViewOptions);
        element: JQuery;
        content: any;
        tagName: string;
        model: Object;
        init(element: Element, options?: ViewOptions): void;
        init(element: string, options?: ViewOptions): void;
        render(container?: any): JQuery;
        destroy(): void;
    }


class ViewContainer extends Observable {
       view: View;
    }


class Layout extends View {
        containers: { [selector: string]: ViewContainer; };
        showIn(selector: string, view: View, transitionClass?: string): void;
    }


class History extends Observable {
        current: string;
        root: string;
        start(options: Object): void;
        stop(): void;
        change(callback: Function): void;
        navigate(location: string, silent?: boolean): void;
    }


class Route extends Class {
        route: RegExp;
        callback(url: string): void;
        worksWith(url: string): void;
    }


class Router extends Observable {
        constructor(options?: RouterOptions);
        routes: Route[];
        init(options?: RouterOptions): void;
        start(): void;
        destroy(): void;
        route(route: string, callback: Function): void;
        navigate(location: string, silent?: boolean): void;
        replace(location: string, silent?: boolean): void;
    }


class Binding extends Observable {
        source: any;
        parents: any[];
        path: string;
        observable: boolean;
        dependencies: { [path: string]: boolean; };
        constructor(parents: any[], path: string);
        change(e: Object): void;
        start(source: kendo.Observable): void;
        stop(source: kendo.Observable): void;
        get (): any;
        set (value: any): void;
        destroy(): void;
    }


class BindingTarget {
        target: any;
        options: any;
        source: any;
    }


class EventBinding extends Binding {
        get (): void;
    }


class TemplateBinding extends Binding {
        constructor(source: kendo.Observable, path: string, template: Function);
        render(value: Object): string;
    }


class Binder extends Class {
        static fn: Binder;
        element: any;
        bindings: Bindings;
        options: BinderOptions;
        constructor(element: any, bindings: Bindings, options?: BinderOptions);
        static extend(prototype: Object): Binder;
        init(element: any, bindings: Bindings, options?: BinderOptions): void;
        bind(binding: Binding, attribute: string): void;
        destroy(): void;
        refresh(): void;
        refresh(attribute: string): void;
    }


class TypedBinder extends Binder {
        dataType(): string;
        parsedValue(): any;
    }


class ObservableObject extends Observable{
        constructor(value?: any);
        uid: string;
        init(value?: any): void;
        get(name: string): any;
        parent(): ObservableObject;
        set(name: string, value: any): void;
        toJSON(): Object;
    }


class Model extends ObservableObject {
        static idField: string;
        static fields: DataSourceSchemaModelFields;

        idField: string;
        _defaultId: any;
        fields: DataSourceSchemaModelFields;
        defaults: {
            [field: string]: any;
        };
        id: any;
        dirty: boolean;
        dirtyFields: any[];

        static define(options: DataSourceSchemaModelWithFieldsObject): typeof Model;
        static define(options: DataSourceSchemaModelWithFieldsArray): typeof Model;

        constructor(data?: any);
        init(data?: any): void;
        accept(data?: any): void;
        editable(field: string): boolean;
        isNew(): boolean;
    }


class SchedulerEvent extends Model {
        static idField: string;
        static fields: DataSourceSchemaModelFields;

        constructor(data?: SchedulerEventData);

        description: string;
        end: Date;
        endTimezone: string;
        isAllDay: boolean;
        id: any;
        start: Date;
        startTimezone: string;
        recurrenceId: any;
        recurrenceRule: string;
        recurrenceException: string;
        title: string;

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


class TreeListModel extends Model {
        static idField: string;
        static fields: DataSourceSchemaModelFields;

        id: any;
        parentId: any;

        static define(options: DataSourceSchemaModelWithFieldsObject): typeof TreeListModel;
        static define(options: DataSourceSchemaModelWithFieldsArray): typeof TreeListModel;

        constructor(data?: any);
        init(data?: any): void;
        loaded(value: boolean): void;
        loaded(): boolean;
    }


class TreeListDataSource extends DataSource {
        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;
    }


class GanttTask extends Model {
        static idField: string;
        static fields: DataSourceSchemaModelFields;

        id: any;
        parentId: number;
        orderId: number;
        title: string;
        start: Date;
        end: Date;
        plannedStart: Date;
        plannedEnd: Date;
        percentComplete: number;
        summary: boolean;
        expanded: boolean;

        static define(options: DataSourceSchemaModelWithFieldsObject): typeof GanttTask;
        static define(options: DataSourceSchemaModelWithFieldsArray): typeof GanttTask;

        constructor(data?: any);
        init(data?: any): void;
    }


class GanttDependency extends Model {
        static idField: string;
        static fields: DataSourceSchemaModelFields;

        id: any;
        predecessorId: number;
        successorId: number;
        type: number;

        static define(options: DataSourceSchemaModelWithFieldsObject): typeof GanttDependency;
        static define(options: DataSourceSchemaModelWithFieldsArray): typeof GanttDependency;

        constructor(data?: any);
        init(data?: any): void;
    }


class Node extends Model {
        children: HierarchicalDataSource;

        append(model: any): void;
        level(): number;
        load(): void;
        loaded(value: boolean): void;
        loaded(): boolean;
        parentNode(): Node;
    }


class FileEntry extends Node {
        children: FileManagerDataSource;
    }


class SchedulerDataSource extends DataSource {
        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;
    }


class GanttDataSource extends DataSource {
        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;
    }


class GanttDependencyDataSource extends DataSource {
        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;
    }


class HierarchicalDataSource extends DataSource {
        constructor(options?: HierarchicalDataSourceOptions);
        init(options?: HierarchicalDataSourceOptions): void;
    }


class FileManagerDataSource extends HierarchicalDataSource {
        constructor(options?: FileManagerDataSourceOptions);
        init(options?: FileManagerDataSourceOptions): void;
    }


class PivotDataSource extends DataSource {
        axes(): PivotSchemaAxes;
        constructor(options?: PivotDataSourceOptions);
        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>;
    }


class ObservableArray extends Observable {
        length: number;
        [index: number]: any;

        constructor(array: 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[];
        parent(): ObservableObject;
        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;
    }


class DataSource extends Observable{
        options: DataSourceOptions;

        static create(options?: DataSourceOptions): DataSource;

        constructor(options?: DataSourceOptions);
        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;
    }


class Query {
        data: any[];

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

        constructor(data: any[]);
        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;
    }


class attr extends Binder { }


class css extends Binder { }


class style extends Binder { }


class enabled extends Binder { }


class disabled extends Binder { }


class readonly extends Binder { }


class events extends Binder { }


class text extends Binder { }


class visible extends Binder { }


class invisible extends Binder { }


class html extends Binder { }


class value extends TypedBinder {
        change(): void;
    }


class source extends Binder {
        container(): Element;
        template(): String;
        add(index: Number, items: any[]): void;
        remove(index: Number, items: any[]): void;
        render(): void;
    }


class checked extends TypedBinder {
        change(): void;
        value(): any;
    }


class source extends binders.source { }


class checked extends Binder {
        change(): void;
        value(): any;
    }


class start extends Binder {
        change(): void;
    }


class end extends Binder {
        change(): void;
    }


class value extends Binder {
        change(): void;
    }


class Widget extends Observable {
        static fn: any;

        element: JQuery;
        options: any;
        events: string[];

        static extend(prototype: Object): Widget;

        constructor(element: Element, options?: Object);
        constructor(element: JQuery, options?: Object);
        constructor(selector: String, options?: Object);
        init(element: Element, options?: Object): void;
        init(element: JQuery, options?: Object): void;
        init(selector: String, options?: Object): void;
        destroy(): void;
        setOptions(options: Object): void;
        resize(force?: boolean): void;
    }


class Draggable extends kendo.ui.Widget{
        element: JQuery;
        currentTarget: JQuery;
        constructor(element: Element, options?: DraggableOptions);
        options: DraggableOptions;

        cancelHold(): void;
    }


class DropTarget extends kendo.ui.Widget{
        element: JQuery;
        constructor(element: Element, options?: DropTargetOptions);
        options: DropTargetOptions;
        static destroyGroup(groupName: string): void;
    }


class DropTargetArea extends kendo.ui.Widget{
        element: JQuery;
        constructor(element: Element, options?: DropTargetAreaOptions);
        options: DropTargetAreaOptions;
    }


class Toolbar extends kendo.ui.Widget{
        element: JQuery;
        options: any;
        tools: any[];
    }


class FileManagerCommand extends kendo.Class {
         static fn: any;
         static extend(prototype: Object): any;
         exec?(): void;
    }


class CreateFolderCommand extends  kendo.Class {
        init?(options: any): void;
        exec?(): void;
    }


class RenameCommand extends  kendo.Class {
        init?(options: any): void;
        exec?(): void;
    }


class DeleteCommand extends  kendo.Class {
        init?(options: any): void;
        exec?(): void;
        removeItems?(items: any): void;
    }


class MoveCommand extends  kendo.Class {
        init?(options: any): void;
        exec?(): void;
    }


class CopyCommand extends  kendo.Class {
        init?(options: any): void;
        exec?(): void;
    }


class SortCommand extends  kendo.Class {
        init?(options: any): void;
        exec?(): void;
    }


class SearchCommand extends  kendo.Class {
        init?(options: any): void;
        exec?(): void;
    }


class ChangeViewCommand extends  kendo.Class {
        init?(options: any): void;
        exec?(): void;
    }


class OpenDialogCommand extends  kendo.Class {
        init?(options: any): void;
        exec?(): void;
    }


class TogglePaneCommand extends  kendo.Class {
        init?(options: any): void;
        exec?(): void;
        getResizable(): void;
    }


class Command extends kendo.Class {
         static fn: any;
         static extend(prototype: Object): any;
         exec?(): void;
    }


class AddColumnCommand extends kendo.ui.taskboard.Command {
    }


class EditColumnCommand extends kendo.ui.taskboard.Command {
    }


class DeleteColumnCommand extends kendo.ui.taskboard.Command {
    }


class SaveColumnCommand extends kendo.ui.taskboard.Command {
    }


class CancelEditColumnCommand extends kendo.ui.taskboard.Command {
    }


class OpenPaneCommand extends kendo.ui.taskboard.Command {
    }


class ClosePaneCommand extends kendo.ui.taskboard.Command {
    }


class SelectCardCommand extends kendo.ui.taskboard.Command {
    }


class MoveFocusCommand extends kendo.ui.taskboard.Command {
    }


class SaveChangesCommand extends kendo.ui.taskboard.Command {
    }


class DeleteCardCommand extends kendo.ui.taskboard.Command {
    }


class MoveCardCommand extends kendo.ui.taskboard.Command {
    }


class EditCardCommand extends kendo.ui.taskboard.Command {
    }


class AddCardCommand extends kendo.ui.taskboard.Command {
    }


class SearchCommand extends kendo.ui.taskboard.Command {
    }


class Application extends Observable {
        options: ApplicationOptions;
        router: kendo.Router;
        pane: kendo.mobile.ui.Pane;

        constructor(element?: any, options?: ApplicationOptions);
        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;
    }


class Widget extends kendo.ui.Widget {
    }


class Shape {
    }


class ActionSheet extends kendo.ui.Widget {

        static fn: ActionSheet;

        options: ActionSheetOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): ActionSheet;

        constructor(element: Element, options?: ActionSheetOptions);

        close(): void;
        destroy(): void;
        open(): void;

    }


class Alert extends kendo.ui.Dialog {

        static fn: Alert;

        options: AlertOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Alert;

        constructor(element: Element, options?: AlertOptions);

    }


class AppBar extends kendo.ui.Widget {

        static fn: AppBar;

        options: AppBarOptions;
        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): AppBar;

        constructor(element: Element, options?: AppBarOptions);
    }


class AutoComplete extends kendo.ui.Widget {

        static fn: AutoComplete;

        options: AutoCompleteOptions;

        dataSource: kendo.data.DataSource;
        list: JQuery;
        ul: JQuery;
        popup: kendo.ui.Popup;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): AutoComplete;

        constructor(element: Element, options?: AutoCompleteOptions);

        close(): void;
        dataItem(index: number): any;
        dataItem(index: Element): any;
        dataItem(index: JQuery): any;
        destroy(): void;
        enable(enable: boolean): void;
        focus(): void;
        items(): any;
        readonly(readonly: boolean): void;
        refresh(): 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;

    }


class Badge extends kendo.ui.Widget {

        static fn: Badge;

        options: BadgeOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Badge;

        constructor(element: Element, options?: BadgeOptions);

        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;

    }


class BottomNavigation extends kendo.ui.Widget {

        static fn: BottomNavigation;

        options: BottomNavigationOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): BottomNavigation;

        constructor(element: Element, options?: BottomNavigationOptions);

        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;

    }


class Breadcrumb extends kendo.ui.Widget {

        static fn: Breadcrumb;

        options: BreadcrumbOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Breadcrumb;

        constructor(element: Element, options?: BreadcrumbOptions);

        value(path: string): void;
        items(items: BreadcrumbItem[]): void;
        destroy(): void;
    }


class Button extends kendo.ui.Widget {

        static fn: Button;

        options: ButtonOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Button;

        constructor(element: Element, options?: ButtonOptions);

        enable(toggle: boolean): void;

    }


class ButtonGroup extends kendo.ui.Widget {

        static fn: ButtonGroup;

        options: ButtonGroupOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): ButtonGroup;

        constructor(element: Element, options?: ButtonGroupOptions);

        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;
        destroy(): void;
        enable(enable: boolean): void;
        select(li: JQuery): void;
        select(li: number): void;
        selectedIndices: Array<number>;

    }


class Calendar extends kendo.ui.Widget {

        static fn: Calendar;

        options: CalendarOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Calendar;

        constructor(element: Element, options?: CalendarOptions);

        current(): Date;
        destroy(): void;
        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;
        value(value: string): void;
        view(): any;

    }


class Chat extends kendo.ui.Widget {

        static fn: Chat;

        options: ChatOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Chat;

        constructor(element: Element, options?: ChatOptions);

        getUser(): any;
        postMessage(message: string): void;
        renderAttachments(options: any, sender: any): void;
        renderMessage(message: any, sender: any): void;
        renderSuggestedActions(suggestedActions: any): void;

    }


class CheckBoxGroup extends kendo.ui.Widget {

        static fn: CheckBoxGroup;

        options: CheckBoxGroupOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): CheckBoxGroup;

        constructor(element: Element, options?: CheckBoxGroupOptions);

        checkAll(select: boolean): void;
        enable(enable: boolean): void;
        enableItem(enable: boolean, index: number): void;
        item(index: number): JQuery;
        items(): JQuery;
        value(): any;
        value(value: any): void;

    }


class ColorPalette extends kendo.ui.Widget {

        static fn: ColorPalette;

        options: ColorPaletteOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): ColorPalette;

        constructor(element: Element, options?: ColorPaletteOptions);

        value(): string;
        value(color?: string): void;
        color(): kendo.Color;
        color(color?: kendo.Color): void;
        enable(enable?: boolean): void;

    }


class ColorPicker extends kendo.ui.Widget {

        static fn: ColorPicker;

        options: ColorPickerOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): ColorPicker;

        constructor(element: Element, options?: ColorPickerOptions);

        close(): void;
        open(): void;
        toggle(): void;
        value(): string;
        value(color?: string): void;
        color(): kendo.Color;
        color(color?: kendo.Color): void;
        enable(enable?: boolean): void;

    }


class ComboBox extends kendo.ui.Widget {

        static fn: ComboBox;

        options: ComboBoxOptions;

        dataSource: kendo.data.DataSource;
        input: JQuery;
        list: JQuery;
        ul: JQuery;
        popup: kendo.ui.Popup;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): ComboBox;

        constructor(element: Element, options?: ComboBoxOptions);

        close(): void;
        dataItem(index?: number): any;
        destroy(): void;
        enable(enable: boolean): void;
        focus(): void;
        items(): any;
        open(): void;
        readonly(readonly: boolean): void;
        refresh(): void;
        search(word: string): void;
        select(): number;
        select(li: JQuery): void;
        select(li: number): void;
        select(li: Function): void;
        setDataSource(dataSource: kendo.data.DataSource): void;
        suggest(value: string): void;
        text(): string;
        text(text: string): void;
        toggle(toggle: boolean): void;
        value(): string;
        value(value: string): void;

    }


class Confirm extends kendo.ui.Dialog {

        static fn: Confirm;

        options: ConfirmOptions;

        result: JQueryPromise<any>;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Confirm;

        constructor(element: Element, options?: ConfirmOptions);

        open(): kendo.ui.Confirm;
    }


class ContextMenu extends kendo.ui.Widget {

        static fn: ContextMenu;

        options: ContextMenuOptions;

        dataSource: kendo.data.DataSource;
        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): ContextMenu;

        constructor(element: Element, options?: ContextMenuOptions);

        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;
        destroy(): void;
        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;

    }


class DateInput extends kendo.ui.Widget {

        static fn: DateInput;

        options: DateInputOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): DateInput;

        constructor(element: Element, options?: DateInputOptions);

        destroy(): void;
        enable(enable: boolean): void;
        readonly(readonly: boolean): void;
        max(): Date;
        max(value: Date): void;
        max(value: string): void;
        min(): Date;
        min(value: Date): void;
        min(value: string): void;
        setOptions(options: any): void;
        value(): Date;
        value(value: Date): void;
        value(value: string): void;

    }


class DatePicker extends kendo.ui.Widget {

        static fn: DatePicker;

        options: DatePickerOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): DatePicker;

        constructor(element: Element, options?: DatePickerOptions);

        close(): void;
        destroy(): void;
        enable(enable: boolean): void;
        readonly(readonly: boolean): void;
        max(): Date;
        max(value: Date): void;
        max(value: string): void;
        min(): Date;
        min(value: Date): void;
        min(value: string): void;
        open(): void;
        setOptions(options: any): void;
        value(): Date;
        value(value: Date): void;
        value(value: string): void;

    }


class DateRangePicker extends kendo.ui.Widget {

        static fn: DateRangePicker;

        options: DateRangePickerOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): DateRangePicker;

        constructor(element: Element, options?: DateRangePickerOptions);

        close(): void;
        destroy(): void;
        enable(enable: boolean): void;
        readonly(readonly: boolean): void;
        max(): Date;
        max(value: Date): void;
        max(value: string): void;
        min(): Date;
        min(value: Date): void;
        min(value: string): void;
        open(): void;
        range(): any;
        range(range: DateRangePickerRange): void;
        setOptions(options: any): void;

    }


class DateTimePicker extends kendo.ui.Widget {

        static fn: DateTimePicker;

        options: DateTimePickerOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): DateTimePicker;

        constructor(element: Element, options?: DateTimePickerOptions);

        close(view: string): void;
        destroy(): void;
        enable(enable: boolean): void;
        readonly(readonly: boolean): void;
        max(): Date;
        max(value: Date): void;
        max(value: string): void;
        min(): Date;
        min(value: Date): void;
        min(value: string): void;
        open(view: string): void;
        setOptions(options: any): void;
        toggle(view: string): void;
        value(): Date;
        value(value: Date): void;
        value(value: string): void;

    }


class Dialog extends kendo.ui.Widget {

        static fn: Dialog;

        options: any;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Dialog;

        constructor(element: Element, options?: DialogOptions);

        center(): kendo.ui.Dialog;
        close(): kendo.ui.Dialog;
        content(): string;
        content(content?: string): kendo.ui.Dialog;
        content(content?: JQuery): kendo.ui.Dialog;
        destroy(): void;
        open(): kendo.ui.Dialog;
        title(): string;
        title(text?: string): kendo.ui.Dialog;
        toFront(): kendo.ui.Dialog;

    }


class Drawer extends kendo.ui.Widget {

        static fn: Drawer;

        options: DrawerOptions;

        element: JQuery;
        wrapper: JQuery;
        visible: boolean;

        static extend(proto: Object): Drawer;

        constructor(element: Element, options?: DrawerOptions);

        destroy(): void;
        hide(): void;
        show(): void;

    }


class DropDownList extends kendo.ui.Widget {

        static fn: DropDownList;

        options: DropDownListOptions;

        dataSource: kendo.data.DataSource;
        span: JQuery;
        filterInput: JQuery;
        list: JQuery;
        ul: JQuery;
        popup: kendo.ui.Popup;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): DropDownList;

        constructor(element: Element, options?: DropDownListOptions);

        close(): void;
        dataItem(index?: JQuery): any;
        dataItem(index?: number): any;
        destroy(): void;
        focus(): void;
        items(): any;
        enable(enable: boolean): void;
        open(): void;
        readonly(readonly: boolean): void;
        refresh(): void;
        search(word: string): void;
        select(): number;
        select(li: JQuery): void;
        select(li: number): void;
        select(li: Function): void;
        setDataSource(dataSource: kendo.data.DataSource): void;
        text(): string;
        text(text: string): void;
        toggle(toggle: boolean): void;
        value(): string;
        value(value: string): void;

    }


class DropDownTree extends kendo.ui.Widget {

        static fn: DropDownTree;

        options: DropDownTreeOptions;

        dataSource: kendo.data.DataSource;
        tagList: JQuery;
        tree: JQuery;
        treeview: kendo.ui.TreeView;
        popup: kendo.ui.Popup;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): DropDownTree;

        constructor(element: Element, options?: DropDownTreeOptions);

        close(): void;
        destroy(): void;
        enable(enable: boolean): void;
        focus(): void;
        items(): any;
        open(): void;
        readonly(readonly: boolean): void;
        refresh(): void;
        search(word: string): void;
        setDataSource(dataSource: kendo.data.HierarchicalDataSource): void;
        toggle(toggle?: boolean): void;
        value(): any;
        value(value: any): void;
        value(value: string): void;

    }


class Editor extends kendo.ui.Widget {

        static fn: Editor;

        options: EditorOptions;

        body: Element;
        toolbar: kendo.ui.editor.Toolbar;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Editor;

        constructor(element: Element, options?: EditorOptions);

        createRange(document?: Document): Range;
        destroy(): void;
        encodedValue(): string;
        exec(name: string, params: any): void;
        focus(): void;
        getRange(): Range;
        getSelection(): Selection;
        paste(html: string, options: any): void;
        selectedHtml(): string;
        refresh(): void;
        saveAsPDF(): JQueryPromise<any>;
        selectRange(range: Range): void;
        update(): void;
        state(toolName: string): boolean;
        value(): string;
        value(value: string): void;

    }


class ExpansionPanel extends kendo.ui.Widget {

        static fn: ExpansionPanel;

        options: ExpansionPanelOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): ExpansionPanel;

        constructor(element: Element, options?: ExpansionPanelOptions);

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

    }


class FileManager extends kendo.ui.Widget {

        static fn: FileManager;

        options: FileManagerOptions;

        dataSource: kendo.data.DataSource;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): FileManager;

        constructor(element: Element, options?: FileManagerOptions);

        path(): string;
        view(): string;
        view(view?: string): void;
        navigate(path: string): void;
        refresh(): void;
        executeCommand(command: string, args?: any): void;
        getSelected(): any | any[];
        getSize(): any;
        setDataSource(dataSource: kendo.data.FileManagerDataSource): void;
        destroy(): void;
        items(): any;
    }


class Filter extends kendo.ui.Widget {

        static fn: Filter;

        options: FilterOptions;

        dataSource: kendo.data.DataSource;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Filter;

        constructor(element: Element, options?: FilterOptions);

        applyFilter(): void;

    }


class FilterMenu extends kendo.ui.Widget {

        static fn: FilterMenu;

        options: FilterMenuOptions;

        field: string;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): FilterMenu;

        constructor(element: Element, options?: FilterMenuOptions);

        clear(): void;

    }


class FlatColorPicker extends kendo.ui.Widget {

        static fn: FlatColorPicker;

        options: FlatColorPickerOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): FlatColorPicker;

        constructor(element: Element, options?: FlatColorPickerOptions);

        focus(): void;
        value(): string;
        value(color?: string): void;
        color(): kendo.Color;
        color(color?: kendo.Color): void;
        enable(enable?: boolean): void;

    }


class FloatingActionButton extends kendo.ui.Widget {

        static fn: FloatingActionButton;

        options: FloatingActionButtonOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): FloatingActionButton;

        constructor(element: Element, options?: FloatingActionButtonOptions);

        text(text: string): void;
        icon(icon: string): void;
        themeColor(themeColor: string): void;
        shape(shape: string): void;
        enable(enable: boolean): void;
        show(): void;
        hide(): void;
        setOptions(options: any): void;
        destroy(): void;
    }


class Form extends kendo.ui.Widget {

        static fn: Form;

        options: FormOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Form;

        constructor(element: Element, options?: FormOptions);

        validate(): void;
        clear(): void;
        setOptions(options: any): void;
        destroy(): void;
    }


class Gantt extends kendo.ui.Widget {

        static fn: Gantt;

        options: GanttOptions;

        dataSource: kendo.data.DataSource;
        dependencies: kendo.data.GanttDependencyDataSource;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Gantt;

        constructor(element: Element, options?: GanttOptions);

        clearSelection(): void;
        dataItem(row: string): kendo.data.GanttTask;
        dataItem(row: Element): kendo.data.GanttTask;
        dataItem(row: JQuery): kendo.data.GanttTask;
        date(date?: Date): Date;
        destroy(): void;
        range(range?: any): any;
        refresh(): void;
        refreshDependencies(): void;
        removeDependency(dependency: string): void;
        removeDependency(dependency: kendo.data.GanttDependency): void;
        removeTask(task: string): void;
        removeTask(task: kendo.data.GanttTask): void;
        saveAsPDF(): JQueryPromise<any>;
        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;

    }


class Grid extends kendo.ui.Widget {

        static fn: Grid;

        options: GridOptions;

        dataSource: kendo.data.DataSource;
        editable?: kendo.ui.Editable;
        columns: GridColumn[];
        footer: JQuery;
        pager: kendo.ui.Pager;
        table: JQuery;
        tbody: JQuery;
        thead: JQuery;
        content: JQuery;
        lockedHeader: JQuery;
        lockedTable: JQuery;
        lockedContent: JQuery;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Grid;

        constructor(element: Element, options?: GridOptions);

        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;
        clearSelection(): void;
        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(): JQuery;
        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;
        destroy(): void;
        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;
        items(): any;
        lockColumn(column: number): void;
        lockColumn(column: string): void;
        refresh(): 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;
        saveAsPDF(): JQueryPromise<any>;
        saveChanges(): void;
        saveRow(): void;
        select(): JQuery;
        select(rows: string): void;
        select(rows: Element): void;
        select(rows: JQuery): void;
        selectedKeyNames(): any;
        setDataSource(dataSource: kendo.data.DataSource): void;
        setOptions(options: any): void;
        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;

    }


class ImageEditor extends kendo.ui.Widget {

        static fn: ImageEditor;

        options: ImageEditorOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): ImageEditor;

        constructor(element: Element, options?: ImageEditorOptions);

        drawImage(imageUrl: string): JQueryPromise<any>;
        drawCanvas(image: any): void;
        getCanvasElement(): HTMLElement;
        getCurrent2dContext(): any;
        getCurrentImage(): HTMLElement;
        getZoomLevel(): number;
        executeCommand(command: string, args?: any): void;

    }


class ListBox extends kendo.ui.Widget {

        static fn: ListBox;

        options: ListBoxOptions;

        dataSource: kendo.data.DataSource;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): ListBox;

        constructor(element: Element, options?: ListBoxOptions);

        clearSelection(): void;
        dataItem(element: JQuery): kendo.data.ObservableObject;
        dataItem(element: Element): kendo.data.ObservableObject;
        dataItem(element: string): kendo.data.ObservableObject;
        dataItems(): kendo.data.ObservableArray;
        destroy(): void;
        enable(element: JQuery, enable?: boolean): void;
        enable(element: Element, enable?: boolean): void;
        enable(element: string, enable?: boolean): void;
        items(): any;
        refresh(): void;
        reorder(element: JQuery, index: number): void;
        reorder(element: Element, index: number): void;
        reorder(element: string, index: number): void;
        remove(element: JQuery): void;
        remove(element: Element): void;
        remove(element: string): void;
        remove(element: any): void;
        select(): JQuery;
        select(items: JQuery): void;
        select(items: any): void;
        setDataSource(dataSource: kendo.data.DataSource): void;

    }


class ListView extends kendo.ui.Widget {

        static fn: ListView;

        options: ListViewOptions;

        dataSource: kendo.data.DataSource;

        element: JQuery;
        content: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): ListView;

        constructor(element: Element, options?: ListViewOptions);

        add(): void;
        cancel(): void;
        clearSelection(): void;
        dataItem(row: string): kendo.data.ObservableObject;
        dataItem(row: Element): kendo.data.ObservableObject;
        dataItem(row: JQuery): kendo.data.ObservableObject;
        dataItems(): kendo.data.ObservableArray;
        destroy(): void;
        edit(item: JQuery): void;
        items(): any;
        refresh(): void;
        remove(item: any): void;
        save(): void;
        select(): JQuery;
        select(items: JQuery): void;
        select(items: any): void;
        setDataSource(dataSource: kendo.data.DataSource): void;

    }


class Loader extends kendo.ui.Widget {

        static fn: Loader;

        options: LoaderOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Loader;

        constructor(element: Element, options?: LoaderOptions);

        show(): void;
        hide(): void;
        setOptions(options: any): void;
    }


class MaskedTextBox extends kendo.ui.Widget {

        static fn: MaskedTextBox;

        options: MaskedTextBoxOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): MaskedTextBox;

        constructor(element: Element, options?: MaskedTextBoxOptions);

        destroy(): void;
        enable(enable: boolean): void;
        readonly(readonly: boolean): void;
        raw(): string;
        value(): string;
        value(value: string): void;

    }


class MediaPlayer extends kendo.ui.Widget {

        static fn: MediaPlayer;

        options: MediaPlayerOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): MediaPlayer;

        constructor(element: Element, options?: MediaPlayerOptions);

        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;
        pause(): void;
        play(): void;
        seek(milliseconds: number): number;
        stop(): void;
        titlebar(): JQuery;
        toolbar(): kendo.ui.ToolBar;

    }


class Menu extends kendo.ui.Widget {

        static fn: Menu;

        options: MenuOptions;

        dataSource: kendo.data.DataSource;
        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Menu;

        constructor(element: Element, options?: MenuOptions);

        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;
        destroy(): void;
        enable(element: string, enable: boolean): kendo.ui.Menu;
        enable(element: Element, enable: boolean): kendo.ui.Menu;
        enable(element: JQuery, enable: boolean): kendo.ui.Menu;
        findByUid(uid: string): JQuery;
        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;

    }


class MultiColumnComboBox extends kendo.ui.Widget {

        static fn: MultiColumnComboBox;

        options: MultiColumnComboBoxOptions;

        dataSource: kendo.data.DataSource;
        input: JQuery;
        list: JQuery;
        ul: JQuery;
        popup: kendo.ui.Popup;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): MultiColumnComboBox;

        constructor(element: Element, options?: MultiColumnComboBoxOptions);

        close(): void;
        dataItem(index?: number): any;
        destroy(): void;
        enable(enable: boolean): void;
        focus(): void;
        items(): any;
        open(): void;
        readonly(readonly: boolean): void;
        refresh(): void;
        search(word: string): void;
        select(): number;
        select(li: JQuery): void;
        select(li: number): void;
        select(li: Function): void;
        setDataSource(dataSource: kendo.data.DataSource): void;
        suggest(value: string): void;
        text(): string;
        text(text: string): void;
        toggle(toggle: boolean): void;
        value(): string;
        value(value: string): void;

    }


class MultiSelect extends kendo.ui.Widget {

        static fn: MultiSelect;

        options: MultiSelectOptions;

        dataSource: kendo.data.DataSource;
        input: JQuery;
        list: JQuery;
        ul: JQuery;
        tagList: JQuery;
        popup: kendo.ui.Popup;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): MultiSelect;

        constructor(element: Element, options?: MultiSelectOptions);

        close(): void;
        dataItems(): any;
        destroy(): void;
        enable(enable: boolean): void;
        focus(): void;
        items(): any;
        open(): void;
        readonly(readonly: boolean): void;
        refresh(): void;
        search(word: string): void;
        setDataSource(dataSource: kendo.data.DataSource): void;
        toggle(toggle?: boolean): void;
        value(): any;
        value(value: any): void;
        value(value: string): void;

    }


class MultiViewCalendar extends kendo.ui.Widget {

        static fn: MultiViewCalendar;

        options: MultiViewCalendarOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): MultiViewCalendar;

        constructor(element: Element, options?: MultiViewCalendarOptions);

        current(): Date;
        destroy(): void;
        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(): any;
        selectDates(dates: any): void;
        selectRange(): any;
        selectRange(range: any): void;
        value(): Date;
        value(value: Date): void;
        value(value: string): void;
        view(): any;

    }


class Notification extends kendo.ui.Widget {

        static fn: Notification;

        options: NotificationOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Notification;

        constructor(element: Element, options?: NotificationOptions);

        error(data: any): void;
        error(data: string): void;
        error(data: Function): void;
        getNotifications(): JQuery;
        hide(): void;
        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;

    }


class NumericTextBox extends kendo.ui.Widget {

        static fn: NumericTextBox;

        options: NumericTextBoxOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): NumericTextBox;

        constructor(element: Element, options?: NumericTextBoxOptions);

        destroy(): void;
        enable(enable: boolean): void;
        readonly(readonly: boolean): void;
        focus(): void;
        max(): number;
        max(value: number): void;
        max(value: string): void;
        min(): number;
        min(value: number): void;
        min(value: string): void;
        step(): number;
        step(value: number): void;
        step(value: string): void;
        value(): number;
        value(value: number): void;
        value(value: string): void;

    }


class PDFViewer extends kendo.ui.Widget {

        static fn: PDFViewer;

        options: PDFViewerOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): PDFViewer;

        constructor(element: Element, options?: PDFViewerOptions);

        fromFile(): void;
        activatePage(): void;
        loadPage(): void;
        execute(): void;
        setOptions(options: any): void;
        destroy(): void;

    }


class Pager extends kendo.ui.Widget {

        static fn: Pager;

        options: PagerOptions;

        dataSource: kendo.data.DataSource;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Pager;

        constructor(element: Element, options?: PagerOptions);

        totalPages(): number;
        pageSize(): number;
        page(): number;
        page(page: number): void;
        refresh(): void;
        destroy(): void;

    }


class PanelBar extends kendo.ui.Widget {

        static fn: PanelBar;

        options: PanelBarOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): PanelBar;

        constructor(element: Element, options?: PanelBarOptions);

        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;
        clearSelection(): void;
        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;
        destroy(): void;
        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;
        remove(element: string): void;
        remove(element: Element): void;
        remove(element: JQuery): void;
        select(): JQuery;
        select(element?: string): void;
        select(element?: Element): void;
        select(element?: JQuery): void;

    }


class PivotConfigurator extends kendo.ui.Widget {

        static fn: PivotConfigurator;

        options: PivotConfiguratorOptions;

        dataSource: kendo.data.DataSource;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): PivotConfigurator;

        constructor(element: Element, options?: PivotConfiguratorOptions);

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

    }


class PivotGrid extends kendo.ui.Widget {

        static fn: PivotGrid;

        options: PivotGridOptions;

        dataSource: kendo.data.DataSource;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): PivotGrid;

        constructor(element: Element, options?: PivotGridOptions);

        cellInfo(columnIndex: number, rowIndex: number): any;
        cellInfoByElement(cell: string): any;
        cellInfoByElement(cell: Element): any;
        cellInfoByElement(cell: JQuery): any;
        destroy(): void;
        refresh(): void;
        setDataSource(dataSource: kendo.data.PivotDataSource): void;
        saveAsExcel(): void;
        saveAsPDF(): JQueryPromise<any>;

    }


class Popup extends kendo.ui.Widget {

        static fn: Popup;
        static TabKeyTrap: any;

        options: PopupOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Popup;

        constructor(element: Element, options?: PopupOptions);

        close(): void;
        open(): void;
        position(): void;
        setOptions(options: any): void;
        toggle(toggle?: boolean): void;
        visible(): boolean;

    }


class ProgressBar extends kendo.ui.Widget {

        static fn: ProgressBar;

        options: ProgressBarOptions;

        progressStatus: JQuery;
        progressWrapper: JQuery;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): ProgressBar;

        constructor(element: Element, options?: ProgressBarOptions);

        enable(enable: boolean): void;
        value(): number;
        value(value: boolean|number): void;

    }


class Prompt extends kendo.ui.Dialog {

        static fn: Prompt;

        options: PromptOptions;

        result: JQueryPromise<any>;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Prompt;

        constructor(element: Element, options?: PromptOptions);

    }


class RadioGroup extends kendo.ui.Widget {

        static fn: RadioGroup;

        options: RadioGroupOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): RadioGroup;

        constructor(element: Element, options?: RadioGroupOptions);

        enable(enable: boolean): void;
        enableItem(enable: boolean, index: number): void;
        item(index: number): JQuery;
        items(): JQuery;
        value(): string;
        value(value: string): void;

    }


class RangeSlider extends kendo.ui.Widget {

        static fn: RangeSlider;

        options: RangeSliderOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): RangeSlider;

        constructor(element: Element, options?: RangeSliderOptions);

        destroy(): void;
        enable(enable: boolean): void;
        value(): any;
        value(startEndArray: any): void;
        values(): any;
        values(selectionStart: number, selectionEnd: number): void;
        resize(): void;

    }


class Rating extends kendo.ui.Widget {

        static fn: Rating;

        options: RatingOptions;

        element: JQuery;
        wrapper: JQuery;
        container: JQuery;

        static extend(proto: Object): Rating;

        constructor(element: Element, options?: RatingOptions);

        value(value: number): void;
        reset(): void;
        enable(enable: boolean): void;
        readonly(enable: boolean): void;
        setOptions(options: any): void;
        destroy(): void;
    }


class ResponsivePanel extends kendo.ui.Widget {

        static fn: ResponsivePanel;

        options: ResponsivePanelOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): ResponsivePanel;

        constructor(element: Element, options?: ResponsivePanelOptions);

        close(): void;
        destroy(): void;
        open(): void;

    }


class Scheduler extends kendo.ui.Widget {

        static fn: Scheduler;

        options: SchedulerOptions;

        dataSource: kendo.data.DataSource;
        resources: any;
        calendar: kendo.ui.Calendar;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Scheduler;

        constructor(element: Element, options?: SchedulerOptions);

        addEvent(data: any): void;
        cancelEvent(): void;
        data(): void;
        date(): Date;
        date(value?: Date): void;
        destroy(): void;
        editEvent(event: string): void;
        editEvent(event: kendo.data.SchedulerEvent): void;
        items(): any;
        occurrenceByUid(uid: string): kendo.data.SchedulerEvent;
        occurrencesInRange(start: Date, end: Date): any;
        refresh(): void;
        removeEvent(event: string): void;
        removeEvent(event: kendo.data.SchedulerEvent): void;
        resourcesBySlot(slot: any): any;
        saveAsPDF(): JQueryPromise<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;
        view(type?: string): void;
        viewName(): string;

    }


class ScrollView extends kendo.ui.Widget {

        static fn: ScrollView;

        options: ScrollViewOptions;

        dataSource: kendo.data.DataSource;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): ScrollView;

        constructor(element: Element, options?: ScrollViewOptions);

        content(content: string): void;
        content(content: JQuery): void;
        destroy(): void;
        next(): void;
        prev(): void;
        refresh(): void;
        scrollTo(page: number, instant: boolean): void;
        setDataSource(dataSource: kendo.data.DataSource): void;

    }


class SkeletonContainer extends kendo.ui.Widget {

        static fn: SkeletonContainer;

        options: SkeletonContainerOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): SkeletonContainer;

        constructor(element: Element, options?: SkeletonContainerOptions);

    }


class Slider extends kendo.ui.Widget {

        static fn: Slider;

        options: SliderOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Slider;

        constructor(element: Element, options?: SliderOptions);

        destroy(): void;
        enable(enable: boolean): void;
        max(): number;
        max(value: number): void;
        max(value: string): void;
        min(): number;
        min(value: number): void;
        min(value: string): void;
        setOptions(options: any): void;
        value(): number;
        value(value: number): void;
        resize(): void;

    }


class Sortable extends kendo.ui.Widget {

        static fn: Sortable;

        options: SortableOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Sortable;

        constructor(element: Element, options?: SortableOptions);

        indexOf(element: JQuery): number;
        items(): JQuery;

    }


class Splitter extends kendo.ui.Widget {

        static fn: Splitter;

        options: SplitterOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Splitter;

        constructor(element: Element, options?: SplitterOptions);

        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;
        destroy(): 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;

    }


class Spreadsheet extends kendo.ui.Widget {

        static fn: Spreadsheet;

        options: SpreadsheetOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Spreadsheet;

        constructor(element: Element, options?: SpreadsheetOptions);

        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>;
        saveAsExcel(): void;
        saveAsPDF(): 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;
        refresh(): 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;

    }


class Switch extends kendo.ui.Widget {

        static fn: Switch;

        options: SwitchOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Switch;

        constructor(element: Element, options?: SwitchOptions);

        check(): boolean;
        check(check: boolean): void;
        destroy(): void;
        enable(enable: boolean): void;
        toggle(): void;
        readonly(readonly: boolean): void;
        setOptions(options: any): void;
    }


class Stepper extends kendo.ui.Widget {
        static fn: Stepper;

        options: StepperOptions;

        element: JQuery;

        static extend(proto: Object): Stepper;

        constructor(element: Element, options?: StepperOptions);

        setOptions(options: any): void;

        enable(value: boolean): void;
        insertAt(index: number, step: kendo.stepper.StepOptions): void;
        next(): void;
        previous(): void;
        removeAt(index: number): void;
        resize(): void;
        select(): kendo.stepper.Step;
        select(index: number): void;
        steps(): kendo.stepper.Step[];
        steps(steps: kendo.stepper.StepOptions[]): void;
    }


class TabStrip extends kendo.ui.Widget {

        static fn: TabStrip;

        options: TabStripOptions;

        dataSource: kendo.data.DataSource;
        tabGroup: JQuery;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): TabStrip;

        constructor(element: Element, options?: TabStripOptions);

        activateTab(item: JQuery): void;
        append(tab: any): kendo.ui.TabStrip;
        contentElement(itemIndex: number): Element;
        contentHolder(itemIndex: number): Element;
        deactivateTab(item: JQuery): void;
        destroy(): 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(): JQuery;
        select(element: string): void;
        select(element: Element): void;
        select(element: JQuery): void;
        select(element: number): void;
        setDataSource(dataSource: any): void;
        setDataSource(dataSource: kendo.data.DataSource): void;

    }


class TaskBoard extends kendo.ui.Widget {

        static fn: TaskBoard;

        options: TaskBoardOptions;

        dataSource: kendo.data.DataSource;
        columnsDataSource: kendo.data.DataSource;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): TaskBoard;

        constructor(element: Element, options?: TaskBoardOptions);

        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;
        items(): JQuery;
        itemsByStatus(status: string): JQuery;
        itemsByColumn(columnElm: JQuery): JQuery;
        load(): void;
        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;
        setDataSource(dataSource: kendo.data.DataSource): void;
        setDataSource(dataSource: any): void;
        setColumnsDataSource(dataSource: kendo.data.DataSource): void;
        setColumnsDataSource(dataSource: any): void;

    }


class TileLayout extends kendo.ui.Widget {

        static fn: TileLayout;

        options: TileLayoutOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): TileLayout;

        constructor(element: Element, options?: TileLayoutOptions);

    }


class TextArea extends kendo.ui.Widget {

        static fn: TextArea;

        options: TextAreaOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): TextArea;

        constructor(element: Element, options?: TextAreaOptions);

        destroy(): void;
        enable(enable: boolean): void;
        focus(): void;
        readonly(readonly: boolean): void;
        value(): string;
        value(value: string): void;

    }


class TextBox extends kendo.ui.Widget {

        static fn: TextBox;

        options: TextBoxOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): TextBox;

        constructor(element: Element, options?: TextBoxOptions);

        destroy(): void;
        enable(enable: boolean): void;
        focus(): void;
        readonly(readonly: boolean): void;
        value(): string;
        value(value: string): void;

    }


class TimePicker extends kendo.ui.Widget {

        static fn: TimePicker;

        options: TimePickerOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): TimePicker;

        constructor(element: Element, options?: TimePickerOptions);

        close(): void;
        destroy(): void;
        enable(enable: boolean): void;
        readonly(readonly: boolean): void;
        max(): Date;
        max(value: Date): void;
        max(value: string): void;
        min(): Date;
        min(value: Date): void;
        min(value: string): void;
        open(): void;
        setOptions(options: any): void;
        value(): Date;
        value(value: Date): void;
        value(value: string): void;

    }


class Timeline extends kendo.ui.Widget {

        static fn: Timeline;

        options: TimelineOptions;

        dataSource: kendo.data.DataSource;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Timeline;

        constructor(element: Element, options?: TimelineOptions);

        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;
        destroy(): void;
        next(): void;
        previous(): void;
        redraw(): void;
        setDataSource(dataSource: kendo.data.DataSource): void;

    }


class ToolBar extends kendo.ui.Widget {

        static fn: ToolBar;

        options: ToolBarOptions;

        element: JQuery;
        wrapper: JQuery;
        overflowAnchor: JQuery;

        popup: kendo.ui.Popup;

        static extend(proto: Object): ToolBar;

        constructor(element: Element, options?: ToolBarOptions);

        add(command: any): void;
        destroy(): 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;

    }


class Tooltip extends kendo.ui.Widget {

        static fn: Tooltip;

        options: TooltipOptions;

        popup: kendo.ui.Popup;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Tooltip;

        constructor(element: Element, options?: TooltipOptions);

        show(element: JQuery): void;
        hide(): void;
        refresh(): void;
        target(): JQuery;

    }


class Touch extends kendo.ui.Widget {

        static fn: Touch;

        options: TouchOptions;

        element: JQuery;
        wrapper: JQuery;

        static extend(proto: Object): Touch;

        constructor(element: Element, options?: TouchOptions);

        cancel(): void;
        destroy(): void;

    }