@progress/kendo-ui/index.d.ts

This package is part of the [Kendo UI for jQuery](http://www.telerik.com/kendo-ui) suite.

// Type definitions for Kendo UI Professional v2025.3.812
// Project: http://www.telerik.com/kendo-ui
// Definitions by: Telerik <https://github.com/telerik>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3

/*
 * Please, submit Pull Requests in the telerik/kendo-ui-core repo at
 * https://github.com/telerik/kendo-ui-core/tree/master/typescript
 *
 * See contributor instructions at
 * https://github.com/telerik/kendo-ui-core#how-to-contribute
 */

declare namespace kendo {
    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;
            };
        };
    };

    var cultures: {[culture: string] : {
        name?: string | undefined;
        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;
        } | undefined;
        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: number;
                twoDigitYearMax: number;
            };
        } | undefined;
        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;
            };
        } | undefined;
    }};

    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;

    interface MediaQueryListEvent {
        isTrusted: boolean;
        bubbles: boolean;
        cancelBubble: boolean;
        composed: boolean;
        currentTarget: JQuery;
        defaultPrevented: boolean;
        eventPhase: number;
        matches: boolean;
        media: string;
        returnValue: boolean;
        srcElement: MediaQueryList;
        target: MediaQueryList;
        timeStamp: number;
        type: string;
    }
    interface MediaQueryHandler {
        mediaQueryList: MediaQueryList;
        onChange(callback: (e: MediaQueryListEvent) => void): MediaQueryHandler;
        onEnter(callback: (e: MediaQueryListEvent) => void): MediaQueryHandler;
        onLeave(callback: (e: MediaQueryListEvent) => void): MediaQueryHandler;
        destroy(): void;
    }

    function mediaQuery(query: string): MediaQueryHandler;

    var ns: string;

    var jQuery: JQueryStatic;

    var keys: {
        INSERT: number;
        DELETE: number;
        BACKSPACE: number;
        TAB: number;
        ENTER: number;
        ESC: number;
        LEFT: number;
        UP: number;
        RIGHT: number;
        DOWN: number;
        END: number;
        HOME: number;
        SPACEBAR: number;
        PAGEUP: number;
        PAGEDOWN: number;
        F2: number;
        F10: number;
        F12: number;
        NUMPAD_PLUS: number;
        NUMPAD_MINUS: number;
        NUMPAD_DOT: number;
    };

    var support: {
        touch: boolean;
        pointers: boolean;
        scrollbar(): number;
        hasHW3D: boolean;
        hasNativeScrolling: boolean;
        devicePixelRatio: number;
        placeholder: boolean;
        zoomLevel: number;
        mobileOS: {
            device: string;
            tablet: any;
            browser: string;
            name: string;
            majorVersion: string;
            minorVersion: string;
            flatVersion: number;
            appMode: boolean;
        };
        browser: {
            edge: boolean;
            msie: boolean;
            webkit: boolean;
            safari: boolean;
            opera: boolean;
            mozilla: boolean;
            version: string;
        };
    };

    var version: string;

    interface TemplateOptions {
        paramName?: string | undefined;
        useWithBlock?: boolean | undefined;
    }

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

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

    interface ViewOptions {
        tagName?: string | undefined;
        wrap?: boolean | undefined;
        model?: Object | undefined;
        evalTemplate?: boolean | undefined;
        useWithBlock?: boolean | undefined;
        init?: ((e: ViewEvent) => void) | undefined;
        show?: ((e: ViewEvent) => void) | undefined;
        hide?: ((e: ViewEvent) => void) | undefined;
    }

    interface ViewEvent {
        sender: View;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }

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

    var history: History;

    interface RouterOptions {
        init?: ((e: RouterEvent) => void) | undefined;
        pushState?: boolean | undefined;
        hashBang?: boolean | undefined;
        root?: string | undefined;
        ignoreCase?: boolean | undefined;
        change?(e: RouterChangeEvent): void;
        routeMissing?(e: RouterRouteMissingEvent): void;
        same?(e: RouterEvent): void;
    }

    interface RouterEvent {
        sender: Router;
        url: string;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }

    interface RouterChangeEvent extends RouterEvent {
        params: any;
        backButtonPressed: boolean;
    }

    interface RouterRouteMissingEvent extends RouterEvent {
        params: any;
    }

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

    function touchDelta(touch1: Touch, touch2: Touch): {
        center: {
            x: number;
            y: number;
        }
        distance: number;
    }

}

declare namespace kendo.chat {
    class ChatMessageBox extends  kendo.Class {
        init?(options: any): void;
        exec?(): void;
        styles?(options: any): void;
    }

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

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

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

    interface Templates {
       heroCard?(): void;
       message?(): void;
    }

    function getComponent(componentName: string): void;
    function getTemplate(templateName: string): kendo.chat.Templates | string;
    function registerComponent(componentName: string, component: kendo.chat.Component): void;
    function registerTemplate(templateName: string, template: string | Function): void;
}

declare namespace kendo.effects {
    function enable(): void;
    function disable(): void;

    interface Element {
        expand(direction: string): effects.Expand;
        expandHorizontal(): effects.Expand;
        expandVertical(): effects.Expand;
        fade(direction: string): effects.Fade;
        fadeIn(): effects.Fade;
        fadeOut(): effects.Fade;
        flip(axis: string, face: JQuery, back: JQuery): effects.Flip;
        flipHorizontal(face: JQuery, back: JQuery): effects.Flip;
        flipVertical(face: JQuery, back: JQuery): effects.Flip;
        pageturn(axis: string, face: JQuery, back: JQuery): effects.PageTurn;
        pageturnHorizontal(face: JQuery, back: JQuery): effects.PageTurn;
        pageturnVertical(face: JQuery, back: JQuery): effects.PageTurn;
        slideIn(direction: string): effects.SlideIn;
        slideInDown(): effects.SlideIn;
        slideInLeft(): effects.SlideIn;
        slideInRight(): effects.SlideIn;
        slideInUp(): effects.SlideIn;
        tile(direction: string, previous: JQuery): effects.Tile;
        tileDown(previous: JQuery): effects.Tile;
        tileLeft(previous: JQuery): effects.Tile;
        tileRight(previous: JQuery): effects.Tile;
        tileUp(previous: JQuery): effects.Tile;
        transfer(target: JQuery): effects.Transfer;
        zoom(direction: string): effects.Zoom;
        zoomIn(): effects.Zoom;
        zoomOut(): effects.Zoom;
    }

    interface Effect {
        play(): JQueryPromise<any>;
        reverse(): JQueryPromise<any>;
        duration(value: number): Effect;
        add(effect: Effect): Effect;
        stop(): Effect;
    }

    interface Expand extends Effect {
        duration(value: number): Expand;
        direction(value: string): Expand;
        stop(): Expand;
        add(effect: Effect): Expand;
    }

    interface Fade extends Effect {
        duration(value: number): Fade;
        direction(value: string): Fade;
        stop(): Fade;
        add(effect: Effect): Fade;
        startValue(value: number): Fade;
        endValue(value: number): Fade;
    }

    interface Flip extends Effect {
        duration(value: number): Flip;
        direction(value: string): Flip;
        stop(): Flip;
        add(effect: Effect): Flip;
    }

    interface PageTurn extends Effect {
        duration(value: number): PageTurn;
        direction(value: string): PageTurn;
        stop(): PageTurn;
        add(effect: Effect): PageTurn;
    }

    interface SlideIn extends Effect {
        duration(value: number): SlideIn;
        direction(value: string): SlideIn;
        stop(): SlideIn;
        add(effect: Effect): SlideIn;
    }

    interface Tile extends Effect {
        duration(value: number): Tile;
        direction(value: string): Tile;
        stop(): Tile;
        add(effect: Effect): Tile;
    }

    interface Transfer extends Effect {
        duration(value: number): Transfer;
        stop(): Transfer;
        add(effect: Effect): Transfer;
    }

    interface Zoom extends Effect {
        duration(value: number): Zoom;
        direction(value: string): Zoom;
        stop(): Zoom;
        add(effect: Effect): Zoom;
        startValue(value: number): Zoom;
        endValue(value: number): Zoom;
    }
}

declare namespace kendo.data {
    interface ObservableObjectEvent {
        sender?: ObservableObject | undefined;
        field?: string | undefined;
    }

    interface ObservableObjectSetEvent extends ObservableObjectEvent {
        value?: any;
        preventDefault?: Function | undefined;
    }

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

    interface Bindings {
        [key: string]: Binding;
    }

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

    interface DataSourceBinder extends Binder {
        itemChange(e: any): string;
        dataBinding(e: any): any;
        dataBound(e: any): any;
    }

    interface BinderOptions {
    }

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

    interface SchedulerEventData {
        description?: string | undefined;
        end?: Date | undefined;
        endTimezone?: string | undefined;
        isAllDay?: boolean | undefined;
        id?: any;
        start?: Date | undefined;
        startTimezone?: string | undefined;
        recurrenceId?: any;
        recurrenceRule?: string | undefined;
        recurrenceException?: string | undefined;
        title?: string | undefined;
    }

    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 OrgChartModel extends Model {
        static idField: string;
        static nameField: string;
        static titleField: string;
        static avatarField: string;
        static fields: DataSourceSchemaModelFields;

        id: any;
        parentId: any;

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

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

    class OrgChartDataSource extends TreeListDataSource {
        groupedItemsTree(field?: String): any[];
        itemChildren(item?: kendo.data.OrgChartModel): kendo.data.OrgChartModel[];
        itemsTree(item?: kendo.data.OrgChartModel, fromView?: boolean): kendo.data.OrgChartModel[];
        prospectParents(item: kendo.data.OrgChartModel): kendo.data.OrgChartModel[];
        toggleChildren(item: kendo.data.OrgChartModel): 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;
    }

    interface HierarchicalDataSourceOptions extends DataSourceOptions {
        schema?: HierarchicalDataSourceSchema | undefined;
    }


    interface HierarchicalDataSourceSchema extends DataSourceSchemaWithOptionsModel {
        model?: HierarchicalDataSourceSchemaModel | undefined;
    }

    interface HierarchicalDataSourceSchemaModel extends DataSourceSchemaModel {
        hasChildren?: any;
        children?: any;
    }

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

    interface FileManagerDataSourceOptions extends HierarchicalDataSourceOptions {
        schema?: FileManagerDataSourceSchema | undefined;
    }

    interface FileManagerDataSourceSchema extends HierarchicalDataSourceSchema {
        model?: FileManagerDataSourceSchemaModel | undefined;
    }

    interface FileManagerDataSourceSchemaModel extends HierarchicalDataSourceSchemaModel {
        isDirectory?: any;
    }

    interface PivotDiscoverRequestRestrictionOptions {
        catalogName: string;
        cubeName: string;
    }

    interface PivotDiscoverRequestDataOptions {
        command: string;
        restrictions: PivotDiscoverRequestRestrictionOptions;
    }

    interface PivotDiscoverRequestOptions {
        data: PivotDiscoverRequestDataOptions;
    }

    interface PivotTransportConnection {
        catalog?: string | undefined;
        cube?: string | undefined;
    }

    interface PivotTransportDiscover {
        cache?: boolean | undefined;
        contentType?: string | undefined;
        data?: any;
        dataType?: string | undefined;
        type?: string | undefined;
        url?: any;
    }

    interface PivotTransport {
        discover?: any;
        read?: any;
    }

    interface PivotTransportWithObjectOperations extends PivotTransport {
        connection: PivotTransportConnection;
        discover?: PivotTransportDiscover | undefined;
        read?: DataSourceTransportRead | undefined;
    }

    interface PivotTransportWithFunctionOperations extends PivotTransport {
        discover?: ((options: DataSourceTransportOptions) => void) | undefined;
        read?: ((options: DataSourceTransportOptions) => void) | undefined;
    }

    interface PivotDataSourceAxisOptions {
        name: string;
        expand?: boolean | undefined;
    }

    interface PivotDataSourceMeasureOptions {
        values: string[];
        axis?: string | undefined;
    }

    interface PivotDataSourceOptions extends DataSourceOptions {
        columns?: string[]|PivotDataSourceAxisOptions[] | undefined;
        measures?: string[]|PivotDataSourceMeasureOptions | undefined;
        rows?: string[]|PivotDataSourceAxisOptions[] | undefined;
        transport?: PivotTransport | undefined;
        schema?: PivotSchema | undefined;
    }

    interface PivotTupleModel {
        children: PivotTupleModel[];
        caption?: string | undefined;
        name: string;
        levelName?: string | undefined;
        levelNum: number;
        hasChildren?: boolean | undefined;
        hierarchy?: string | undefined;
    }

    interface PivotSchemaRowAxis {
        tuples: PivotTupleModel[];
    }

    interface PivotSchemaColumnAxis {
        tuples: PivotTupleModel[];
    }

    interface PivotSchemaAxes {
        rows: PivotSchemaRowAxis;
        columns: PivotSchemaColumnAxis;
    }

    interface PivotSchema extends DataSourceSchema{
        axes?: any;
        catalogs?: any;
        cubes?: any;
        cube?: any;
        data?: any;
        dimensions?: any;
        hierarchies?: any;
        levels?: any;
        measures?: any;
    }

    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 PivotDataSourceV2 extends Observable {


        options: PivotDataSourceV2Options;


        constructor(options?: PivotDataSourceV2Options);


        axes(): any;
        catalog(): string;
        catalog(name: string): void;
        columns(): any;
        columns(val: any): void;
        cube(): string;
        cube(name: string): void;
        discover(options: string): any;
        measures(): any;
        measures(val: any): void;
        measuresAxis(): string;
        rows(): any;
        rows(val: any): void;
        schemaCatalogs(): any;
        schemaCubes(): any;
        schemaDimensions(): any;
        schemaHierarchies(dimensionName: string): any;
        schemaLevels(hierarchyName: string): any;
        schemaMeasures(): any;

    }

    interface PivotDataSourceV2Column {
        expand?: boolean;
        name?: string;
    }

    interface PivotDataSourceV2Measure {
        values?: any;
        axis?: string;
    }

    interface PivotDataSourceV2Row {
        expand?: boolean;
        name?: string;
    }

    interface PivotDataSourceV2TransportConnection {
        catalog?: string;
        cube?: string;
    }

    interface PivotDataSourceV2Transport {
        discover?: any|string|Function;
        connection?: PivotDataSourceV2TransportConnection;
    }

    interface PivotDataSourceV2Options {
        name?: string | undefined;
        columns?: PivotDataSourceV2Column[] | undefined;
        measures?: PivotDataSourceV2Measure[] | undefined;
        rows?: PivotDataSourceV2Row[] | undefined;
        transport?: PivotDataSourceV2Transport | undefined;
    }
    interface PivotDataSourceV2Event {
        sender: PivotDataSourceV2;
        preventDefault: Function;
        isDefaultPrevented(): boolean;
    }


    interface DataSourceTransport {
        create?: string | DataSourceTransportCreate | ((options: DataSourceTransportOptions) => void) | undefined;
        destroy?: string | DataSourceTransportDestroy | ((options: DataSourceTransportOptions) => void) | undefined;
        push?: Function | undefined;
        submit?: Function | undefined;
        batch?: DataSourceTransportBatch | ((options: DataSourceTransportOptions) => void) | undefined;
        read?: string | DataSourceTransportRead | ((options: DataSourceTransportOptions) => void) | undefined;
        signalr?: DataSourceTransportSignalr | ((options: DataSourceTransportOptions) => void) | undefined;
        update?: string | DataSourceTransportUpdate | ((options: DataSourceTransportOptions) => void) | undefined;
        parameterMap?(data: DataSourceTransportParameterMapData, type: "create"|"destroy"|"read"|"update"): any;
    }

    interface DataSourceTransportSignalrClient {
        create?: string | undefined;
        destroy?: string | undefined;
        read?: string | undefined;
        update?: string | undefined;
    }

    interface DataSourceTransportSignalrServer {
        create?: string | undefined;
        destroy?: string | undefined;
        read?: string | undefined;
        update?: string | undefined;
    }

    interface DataSourceTransportSignalr {
        client?: DataSourceTransportSignalrClient | undefined;
        hub?: any;
        promise?: any;
        server?: DataSourceTransportSignalrServer | undefined;
    }


    interface DataSourceParameterMapDataAggregate {
        field?: string | undefined;
        aggregate?: string | undefined;
    }

    interface DataSourceParameterMapDataGroup {
        aggregate?: DataSourceParameterMapDataAggregate[] | undefined;
        field?: string | undefined;
        dir?: string | undefined;
    }

    interface DataSourceParameterMapDataFilter {
        field?: string | undefined;
        filters?: DataSourceParameterMapDataFilter[] | undefined;
        logic?: string | undefined;
        operator?: string | undefined;
        value?: any;
    }

    interface DataSourceParameterMapDataSort {
        field?: string | undefined;
        dir?: string | undefined;
    }

    interface DataSourceTransportParameterMapData {
        aggregate?: DataSourceParameterMapDataAggregate[] | undefined;
        group?: DataSourceParameterMapDataGroup[] | undefined;
        filter?: DataSourceParameterMapDataFilter | undefined;
        models?: Model[] | undefined;
        page?: number | undefined;
        pageSize?: number | undefined;
        skip?: number | undefined;
        sort?: DataSourceParameterMapDataSort[] | undefined;
        take?: number | undefined;
    }

    interface DataSourceSchema {
        model?: any;
    }

    interface DataSourceSchemaWithTimezone extends DataSourceSchema {
        timezone?: String | undefined;
    }

    interface DataSourceSchemaWithOptionsModel extends DataSourceSchema {
        model?: DataSourceSchemaModel | undefined;
    }

    interface DataSourceSchemaWithConstructorModel extends DataSourceSchema {
        model?:  typeof Model | undefined;
    }

    interface DataSourceSchemaModel {
        id?: string | undefined;
        fields?: any;
        [index: string]: any;
    }

    interface DataSourceSchemaModelWithFieldsArray extends DataSourceSchemaModel {
        fields?: DataSourceSchemaModelField[] | undefined;
    }

    interface DataSourceSchemaModelWithFieldsObject extends DataSourceSchemaModel {
        fields?: DataSourceSchemaModelFields | undefined;
    }

    interface DataSourceSchemaModelFields {
        [index: string]: DataSourceSchemaModelField;
    }

    interface DataSourceSchemaModelField {
        field?: string | undefined;
        from?: string | undefined;
        defaultValue?: any;
        editable?: boolean | undefined;
        nullable?: boolean | undefined;
        parse?: Function | undefined;
        type?: string | undefined;
        validation?: DataSourceSchemaModelFieldValidation | undefined;
    }

    interface DataSourceSchemaModelFieldValidation {
        required?: boolean | undefined;
        min?: any;
        max?: any;
        minLength?: any;
        maxLength?: any;
        [rule: string]: 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;
        reduce(callback: (item: Object, index: number, source: ObservableArray) => any): any[];
        reduceRight(callback: (item: Object, index: number, source: ObservableArray) => any): any[];
        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;
    }

    interface ObservableArrayEvent {
        field?: string | undefined;
        action?: string | undefined;
        index?: number | undefined;
        items?: kendo.data.Model[] | undefined;
    }

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

    interface QueryResult {
        total?: number | undefined;
        data?: any[] | undefined;
    }

    interface DataSourceAggregateItem {
        field?: string | undefined;
        aggregate?: string | undefined;
    }

    interface DataSourceFilter {
    }

    interface DataSourceFilterItem extends DataSourceFilter {
        operator?: string|Function | undefined;
        field?: string | undefined;
        value?: any;
    }

    interface DataSourceFilters extends DataSourceFilter {
        logic?: string | undefined;
        filters?: DataSourceFilter[] | undefined;
    }

    interface DataSourceGroupItemAggregate {
        field?: string | undefined;
        aggregate?: string | undefined;
    }

    interface DataSourceGroupItem {
        field?: string | undefined;
        dir?: string | undefined;
        aggregates?: DataSourceGroupItemAggregate[] | undefined;
        compare?: ((a: DataSourceGroupCompareItem, b: DataSourceGroupCompareItem) => number) | undefined;
    }

    interface DataSourceGroupCompareItem {
        field: string;
        value: any;
        items: any[];
    }

    interface DataSourceSchema {
        aggregates?: any;
        data?: any;
        errors?: any;
        groups?: any;
        parse?: Function | undefined;
        total?: any;
        type?: string | undefined;
    }

    interface DataSourceSortItem {
        field?: string | undefined;
        dir?: string | undefined;
        compare?: Function | undefined;
    }

    interface DataSourceTransportBatch extends JQueryAjaxSettings {
        cache?: boolean | undefined;
        contentType?: string | undefined;
        data?: any;
        dataType?: string | undefined;
        type?: string | undefined;
        url?: any;
    }

    interface DataSourceTransportCreate extends JQueryAjaxSettings {
        cache?: boolean | undefined;
        contentType?: string | undefined;
        data?: any;
        dataType?: string | undefined;
        type?: string | undefined;
        url?: any;
    }

    interface DataSourceTransportDestroy extends JQueryAjaxSettings {
        cache?: boolean | undefined;
        contentType?: string | undefined;
        data?: any;
        dataType?: string | undefined;
        type?: string | undefined;
        url?: any;
    }

    interface DataSourceTransportRead extends JQueryAjaxSettings {
        cache?: boolean | undefined;
        contentType?: string | undefined;
        data?: any;
        dataType?: string | undefined;
        type?: string | undefined;
        url?: any;
    }

    interface DataSourceTransportUpdate extends JQueryAjaxSettings {
        cache?: boolean | undefined;
        contentType?: string | undefined;
        data?: any;
        dataType?: string | undefined;
        type?: string | undefined;
        url?: any;
    }

    interface DataSourceTransportWithObjectOperations extends DataSourceTransport {
        create?: DataSourceTransportCreate | undefined;
        destroy?: DataSourceTransportDestroy | undefined;
        read?: DataSourceTransportRead | undefined;
        update?: DataSourceTransportUpdate | undefined;
    }

    interface DataSourceTransportWithFunctionOperations extends DataSourceTransport {
        create?: ((options: DataSourceTransportOptions) => void) | undefined;
        destroy?: ((options: DataSourceTransportOptions) => void) | undefined;
        read?: ((options: DataSourceTransportReadOptions) => void) | undefined;
        update?: ((options: DataSourceTransportOptions) => void) | undefined;
    }

    interface DataSourceTransportOptions {
        success: (data?: any) => void;
        error: (error?: any) => void;
        data: any;
    }

    interface DataSourceTransportReadOptionsData {
        sort?: DataSourceSortItem[] | undefined;
        filter?: DataSourceFilters | undefined;
        group?: DataSourceGroupItem[] | undefined;
        take?: number | undefined;
        skip?: number | undefined;
    }

    interface DataSourceTransportReadOptions extends DataSourceTransportOptions {
        data: DataSourceTransportReadOptionsData;
    }

    interface DataSourceTransportBatchOptionsData {
        models: any[];
    }

    interface DataSourceTransportBatchOptions extends DataSourceTransportOptions {
        data: DataSourceTransportBatchOptionsData;
    }

    interface DataSourceOptions {
        aggregate?: DataSourceAggregateItem[] | undefined;
        autoSync?: boolean | undefined;
        batch?: boolean | undefined;
        data?: any;
        filter?: any;
        group?: DataSourceGroupItem | DataSourceGroupItem[] | undefined;
        inPlaceSort?: boolean | undefined;
        offlineStorage?: any;
        page?: number | undefined;
        pageSize?: number | undefined;
        schema?: DataSourceSchema | undefined;
        serverAggregates?: boolean | undefined;
        serverFiltering?: boolean | undefined;
        serverGrouping?: boolean | undefined;
        serverPaging?: boolean | undefined;
        serverSorting?: boolean | undefined;
        sort?: any;
        transport?: DataSourceTransport | undefined;
        type?: string | undefined;
        change? (e: DataSourceChangeEvent): void;
        error?(e: DataSourceErrorEvent): void;
        push?(e: DataSourcePushEvent): void;
        sync?(e: DataSourceEvent): void;
        requestStart?(e: DataSourceRequestS