declare namespace Jade.UI {
    enum CssClass {
        MultiMessageDialog = "-jadejs-multi-msg-dialog",
        MultiMessageDialogTitle = "-jadejs-multi-msg-dialog-title",
        MultiMessageDialogContent = "-jadejs-multi-msg-dialog-content",
        MultiMessageDialogContentItem = "-jadejs-multi-msg-dialog-content-item",
        MultipleChoiceDialog = "-jadejs-multi-choice-dialog",
        MultipleChoiceDialogContent = "-jadejs-multi-choice-dialog-content",
        MultipleChoiceDialogContentItem = "-jadejs-multi-choice-dialog-content-item",
        MultipleChoiceDialogContentHeader = "-jadejs-multi-choice-dialog-content-header"
    }
}
declare namespace Jade.UI {
    class Control implements IControl {
        private m_node;
        private m_state;
        private m_controls;
        private m_container;
        private m_subscriptions;
        private m_tags;
        private m_firedEvents;
        private m_onBrowserResizeSubscription;
        constructor(options: IControlOptions);
        get type(): string;
        get ID(): string;
        get controls(): IControlCollection<Control>;
        get state(): StateBag;
        get node(): JQuery;
        get insertAt(): string;
        protected get container(): JQuery;
        protected set container(value: JQuery);
        protected get subscriptions(): ControlEventSubscriptions;
        get tags(): ControlTagCollection;
        get isDetached(): boolean;
        get isBrowserResizeAware(): boolean;
        set isBrowserResizeAware(value: boolean);
        protected onBrowserResize(): void;
        protected onInit(e: ControlEventArgs): void;
        protected onLoad(e: ControlEventArgs): void;
        protected onTemplate(e: ControlEventArgs): void;
        protected onTemplated(e: ControlEventArgs): void;
        protected onRender(e: ControlEventArgs): void;
        protected onActivate(e: ControlEventArgs): void;
        protected onComplete(e: ControlEventArgs): void;
        protected onDestroy(e: ControlEventArgs): void;
        protected onDetach(e: ControlEventArgs): void;
        protected onAttach(e: ControlEventArgs): void;
        protected onStateChanged(): void;
        template(): string | JQuery | Array<string>;
        destroy(): void;
        detach(): void;
        protected attachToDOM(e: ControlEventArgs): void;
        protected setControlOptions(options: any): void;
        protected getDefaultOptions(): any;
        fireEvent(eventName: string, args: ControlEventArgs): void;
        private wrapEventMethods;
        private wrapAndAssignEventMethod;
        private fireEvents;
        protected wrapTemplate(template: JQuery): JQuery;
        private setTemplate;
        private parseTemplate;
        private setDomAttachment;
        private setBrowserResizeAwareness;
    }
}
declare namespace Jade.UI {
    interface IContextMenuSegmentRegistration {
        type: string;
        context?: Function;
    }
    interface IContextMenuOptions extends IControlOptions {
        filter?: string;
        segments?: Array<IContextMenuSegmentRegistration>;
        open?: (e: kendo.ui.ContextMenuOpenEvent) => void;
    }
    class ContextMenu extends Control {
        private m_items;
        private m_instance;
        private m_segments;
        private m_openCallback;
        constructor(options: IContextMenuOptions);
        private get filter();
        private get items();
        private get segments();
        get instance(): kendo.ui.ContextMenu;
        get openCallback(): (e: kendo.ui.ContextMenuOpenEvent) => void;
        protected onInit(e: ControlEventArgs): void;
        onActivate(e: ControlEventArgs): void;
        onClick(e: kendo.ui.ContextMenuSelectEvent): void;
        onOpen(e: kendo.ui.ContextMenuOpenEvent): void;
        onTemplate(e: ControlEventArgs): void;
        onDestroy(e: ControlEventArgs): void;
        template(): string | Array<string> | JQuery;
        protected mergeOptions(settings: any): any;
        private addSegments;
        private resolveSegments;
        private addItems;
        private iterateItems;
        private iterateNodes;
    }
}
declare namespace Jade.UI {
    class ContextMenuEventArgs {
        private m_menu;
        private m_target;
        private m_context;
        constructor(options: {
            menu: ContextMenu;
            target: JQuery;
            context: any;
        });
        get menu(): ContextMenu;
        get target(): JQuery;
        get context(): any;
    }
}
declare namespace Jade.UI {
    class ContextMenuItemBase {
        private m_state;
        private m_items;
        constructor(options: any);
        protected get items(): any;
        protected get state(): StateBag;
        get ID(): string;
        protected onInit(e: any): void;
        protected onLoad(e: any): void;
        protected onComplete(e: any): void;
        protected onClick(e: any): void;
        protected onOpen(e: ContextMenuItemOpenEventArgs): void;
        init(e?: any): void;
        load(e?: any): void;
        complete(e?: any): void;
        click(e?: any): void;
        open(e?: any): void;
        toJSON(): any;
        protected getDefaultOptions(): any;
        protected setOptions(options: any): void;
        protected applyTemplate(data?: any): string;
    }
}
declare namespace Jade.UI {
    class ContextMenuItem extends ContextMenuItemBase {
        private m_command;
        constructor(options: any);
        protected get command(): Function;
        protected onInit(e: any): void;
        protected onClick(e: any): void;
        private assignCommand;
    }
}
declare namespace Jade.UI {
    class ContextMenuItemCollection extends Collection<ContextMenuItemBase> {
        contains(item: ContextMenuItemBase): boolean;
    }
}
declare namespace Jade.UI {
    class ContextMenuItemCommand extends ContextMenuItemBase {
        private m_commandBag;
        constructor(options: any);
        protected get commandBag(): CommandBag;
        protected onClick(e: any): void;
        protected onOpen(e: ContextMenuItemOpenEventArgs): void;
        private bind;
        private getTemplate;
        private setDefaultValues;
    }
}
declare namespace Jade.UI {
    class ContextMenuItemOpenEventArgs {
        private m_item;
        private m_menu;
        private m_context;
        private m_target;
        private m_node;
        constructor(options: {
            menu: ContextMenu;
            item: ContextMenuItemBase;
            node: JQuery;
            target: JQuery;
            context: any;
        });
        get menu(): ContextMenu;
        get item(): ContextMenuItemBase;
        get node(): JQuery;
        get target(): JQuery;
        private get context();
        enabled(value: boolean): void;
        label(value: string): void;
        icon(value: string): void;
        visible(value: boolean): void;
    }
}
declare namespace Jade.UI {
    class ContextMenuItemTemplate {
        apply(e?: any): string;
    }
}
declare namespace Jade.UI {
    class ContextMenuOnAddItemsEventArgs {
        private m_items;
        private m_menu;
        private m_segment;
        constructor(options: {
            menu: ContextMenu;
            items: ContextMenuItemCollection;
            segment: ContextMenuSegment;
        });
        addItem(item: ContextMenuItemBase): void;
        addSeparator(): void;
    }
}
declare namespace Jade.UI {
    class ContextMenuSegment {
        private m_oldContext;
        private m_newContext;
        private m_items;
        constructor(context: any);
        protected get oldContext(): any;
        protected get context(): any;
        get items(): ContextMenuItemCollection;
        onAddItems(e: ContextMenuOnAddItemsEventArgs): void;
        meetsLoadConditions(e: any): boolean;
        open(menu: ContextMenu, target: JQuery): void;
        click(menu: ContextMenu, target: JQuery, item: ContextMenuItemBase): void;
        protected onOpen(e: any): void;
        protected onClick(e: any): void;
        private hidePairedSeparators;
    }
}
declare namespace Jade.UI {
    class ContextMenuUtil {
        static transformContext(context: any, target?: any): any;
    }
}
declare namespace Jade.UI {
    class CommandBag {
        private m_options;
        private m_contextId;
        private m_command;
        private m_commandId;
        private m_commandInfo;
        constructor(options: {
            contextId?: string;
            commandId: string;
        });
        get context(): Context;
        protected get contextId(): string;
        protected get commandContext(): CommandContext;
        protected get commandId(): string;
        get command(): Command;
        protected get options(): StateBag;
        execute(e: any): void;
        bind(): void;
        isCommandResolved(): boolean;
        private ensureCommandInfo;
        private ensureContext;
    }
}
declare namespace Jade.UI {
    class ControlCollection<TControl extends Control> extends Jade.ObservableMappedCollection<TControl> implements IControlCollection<TControl> {
        private m_parent;
        private m_controlEvents;
        constructor(parent: Control, callbacks?: IControlCollectionEventCallbacks<TControl>);
        get parent(): Control;
        get controlEvents(): ControlCollectionControlEvents;
        add(item: TControl): boolean;
        detach(item: TControl): void;
        insert(item: TControl, index: number): boolean;
        remove(item: TControl): TControl;
        clear(): void;
        reverse(): void;
        getById(id: string): TControl;
    }
    interface IControlCollection<TControl extends Control> {
        parent: Control;
        controlEvents: ControlCollectionControlEvents;
        add(item: TControl): boolean;
        clear(): void;
        count: number;
        detach(item: TControl): void;
        each(callback: Function): void;
        indexOf(item: TControl): number;
        insert(item: TControl, index: number): void;
        item(index: number): TControl;
        remove(item: TControl): TControl;
        first(): TControl;
        last(): TControl;
        getById(id: String): TControl;
        getByType<T1 extends TControl>(type: {
            new (...args: any[]): T1;
        }): Collection<T1>;
        toArray(): Array<TControl>;
        reverse(): void;
    }
    interface IControlCollectionEventCallbacks<T> extends Jade.IObservableCollectionEventCallbacks<T> {
        onBeforeDetach?(e: Jade.ObservableCollectionBeforeChangeEventArgs<T>): any;
        onAfterDetach?(e: Jade.ObservableCollectionChangeEventArgs<T>): any;
    }
}
declare namespace Jade.UI {
    class ControlCollectionControlEvents {
        private m_collection;
        private m_firedEvents;
        constructor(collection: ControlCollection<Control>);
        get collection(): ControlCollection<Control>;
        private get firedEvents();
        hasEventFired(eventName: string): boolean;
        fireEvent(eventName: string): void;
        syncControlEvents(item: Control): void;
        private fireControlEvent;
        private addToFiredEvents;
    }
}
declare namespace Jade.UI {
    class ControlEventArgs {
        private m_parent;
        constructor(parent: Control);
        get parent(): Control;
        get node(): JQuery;
        get insertAtNode(): JQuery;
    }
}
declare namespace Jade.UI {
    class ControlEventSubscriptions {
        m_subscriptions: Array<EventBusSubscription>;
        private get subscriptions();
        private get eventBus();
        add(eventName: string, callback: Function, eventBus?: ContextEventBus): EventBusSubscription;
        clear(): void;
    }
}
declare namespace Jade.UI {
    enum ControlEvent {
        onInit = "onInit",
        onLoad = "onLoad",
        onTemplate = "onTemplate",
        onRender = "onRender",
        onActivate = "onActivate",
        onComplete = "onComplete",
        onDestroy = "onDestroy",
        onDetach = "onDetach"
    }
    class ControlEvents {
        private static m_autoInvokedControlEvents;
        private static m_detachedControlEvents;
        static get autoInvokedControlEvents(): IReadOnlyCollection<string>;
        static get detachedControlEvents(): IReadOnlyCollection<string>;
    }
}
declare namespace Jade.UI {
    class ControlTagCollection {
        private m_collection;
        add(tags: string | Array<string>): void;
        remove(tags: string | Array<string>): void;
        match(tags: Array<string>, exactMatch?: boolean): boolean;
        private addTag;
        private addTags;
        private removeTag;
        private removeTags;
    }
}
declare namespace Jade.UI {
    interface IControl {
        template(): string | JQuery | Array<string>;
    }
}
declare namespace Jade.UI {
    interface IControlOptions {
        id?: string;
        insertChildrenAt?: string;
        insertAt?: string;
        [propName: string]: any;
    }
}
declare namespace Jade.UI {
    interface IDialogOptions extends IControlOptions {
        callbacks: {
            [key: string]: (sender: Window, e?: any) => void;
        };
        [key: string]: any;
    }
    interface IDialogOnCreateContextArgs {
        contextId: string;
        contextName: string;
    }
    interface IDialogOnDestroyContextArgs {
        contextId: string;
    }
    class Dialog extends Control {
        private m_window;
        constructor(options?: any, windowOptions?: any);
        get context(): Context;
        get window(): Window;
        get title(): string;
        onRender(e: ControlEventArgs): void;
        protected onComplete(e: ControlEventArgs): void;
        onResize(e: any): void;
        close(options?: any): void;
        center(): void;
        destroy(): void;
        setTitle(title: string): void;
        setDimensions(height: any, width: any): void;
        static open(options?: any, windowOptions?: any): Dialog;
        protected getDefaultOptions(): any;
        protected setControlOptions(options: any): void;
        protected getWindowOptions(): any;
        protected onCreateContext(e: IDialogOnCreateContextArgs): void;
        protected onDestroyContext(e: IDialogOnDestroyContextArgs): void;
        protected setDefaultInputFocus(): void;
        protected setDefaultInputReturnKeystrokeBehavior(): void;
        protected onInputReturnKeystroke(): void;
        private createWindow;
    }
}
declare namespace Jade.UI {
    interface IWindowOptions {
    }
    interface IWindowCallbackOptions {
        [key: string]: (options: any) => void;
    }
    class Window {
        private m_container;
        private m_content;
        private m_callbacks;
        private m_options;
        private m_instance;
        private m_browserResizeSubscription;
        constructor(options: IWindowOptions, callbacks?: IWindowCallbackOptions);
        get ID(): string;
        private get contextId();
        private get callbacks();
        get container(): JQuery;
        set container(value: JQuery);
        get content(): JQuery;
        set content(value: JQuery);
        private get instance();
        private set instance(value);
        private get options();
        get kendo(): kendo.ui.Window;
        get buttonRestore(): JQuery;
        get buttonMaximize(): JQuery;
        get buttonClose(): JQuery;
        private onRefresh;
        private onResize;
        private onBrowserResize;
        center(): void;
        close(options?: any): void;
        destroy(): void;
        setContent(content: any): void;
        setDimensions(height: any, width: any): void;
        setOptions(options: any): void;
        setTitle(title: string): void;
        private frame;
        private activate;
        private setWindowOptions;
        private setWindowCallbacks;
        private invokeCallback;
        private setWindowButtonIcons;
        createContext(): void;
        destroyContext(): void;
        destroyEventSubscriptions(): void;
    }
}
declare namespace Jade.UI {
    enum MessageDialogStyle {
        Success = 1,
        Error = 2,
        Warning = 3,
        Information = 4
    }
    enum MessageDialogButtonStyle {
        OK = 1,
        OKCancel = 2,
        YesNo = 3,
        YesNoCancel = 4
    }
    enum MessageDialogButton {
        ok = 1,
        cancel = 2,
        yes = 3,
        no = 4
    }
    interface IMessageDialogBaseOptions {
        dialogStyle?: MessageDialogStyle;
        dialogButtons?: MessageDialogButtonStyle;
        icon?: string;
        title?: string;
        select?(e: IMessageDialogResponse): void;
        [key: string]: any;
    }
    interface IMessageDialogButtonOptions {
        label: string;
        value: MessageDialogButton;
    }
    interface IMessageDialogStyleSettings {
        icon?: string;
        title: string;
    }
    interface IMessageDialogResponse {
        close(): void;
        button: MessageDialogButton;
        [key: string]: any;
    }
    abstract class MessageDialogBase extends Dialog {
        protected buttons: {
            [key: string]: IMessageDialogButtonOptions;
        };
        protected static styles: {
            [key: number]: IMessageDialogStyleSettings;
        };
        constructor(options: IMessageDialogOptions, windowOptions?: any);
        protected get buttonsNode(): JQuery;
        protected get contentNode(): JQuery;
        protected get selectCallback(): (e: IMessageDialogResponse) => void;
        template(): string | JQuery | Array<string>;
        protected createButton(buttonId: string): void;
        protected getWindowOptions(): any;
        protected select(selectionId: string): void;
        private createButtons;
        private getStyle;
        private setIcon;
        private setFocus;
    }
}
declare namespace Jade.UI {
    interface IErrorDetail {
        code?: number;
        message: string;
        tags: {
            [id: string]: any;
        };
    }
    interface IErrorDialogOptions extends IMessageDialogBaseOptions {
        errors?: Array<IErrorDetail>;
        message?: string;
    }
    class ErrorDialog extends MessageDialogBase {
        constructor(options: IErrorDialogOptions, windowOptions?: any);
        private get errors();
        private get message();
        static open(options: IErrorDialogOptions, windowOptions?: any): ErrorDialog;
        protected onActivate(e: Jade.UI.ControlEventArgs): void;
        protected getWindowOptions(): any;
    }
}
declare namespace Jade.UI {
    interface IErrorDialogContentOptions extends Jade.UI.IControlOptions {
        errors: Array<IErrorDetail>;
        message?: string;
    }
    class ErrorDialogContent extends Jade.UI.Control {
        constructor(options: IErrorDialogContentOptions);
        private get errors();
        private get treeNode();
        private get message();
        template(): string | Array<string> | JQuery;
        protected onActivate(e: Jade.UI.ControlEventArgs): void;
        private tree_init;
        private tree_data;
    }
}
declare namespace Jade.UI {
    interface IMessageDialogOptions extends IMessageDialogBaseOptions {
        message?: string;
        allowClose?: boolean;
    }
    class MessageDialog extends MessageDialogBase {
        constructor(options: IMessageDialogOptions, windowOptions?: any);
        private get message();
        private get allowClose();
        setMessage(message: string): void;
        static open(options?: IMessageDialogOptions, windowOptions?: any): MessageDialog;
        protected getWindowOptions(): any;
    }
}
declare namespace Jade.UI {
    interface IMultiMessageDialogOptions extends IMessageDialogBaseOptions {
        header: string;
        messages: Array<string>;
    }
    class MultiMessageDialog extends MessageDialogBase {
        constructor(options: IMultiMessageDialogOptions, windowOptions?: any);
        private get messages();
        private get header();
        static open(options: IMultiMessageDialogOptions, windowOptions?: any): MultiMessageDialog;
        protected onActivate(e: Jade.UI.ControlEventArgs): void;
        protected getWindowOptions(): any;
    }
}
declare namespace Jade.UI {
    interface IMultiMessageDialogContentOptions extends Jade.UI.IControlOptions {
        header: string;
        messages: Array<string>;
    }
    class MultiMessageDialogContent extends Jade.UI.Control {
        constructor(options: IMultiMessageDialogContentOptions);
        private get messages();
        private get header();
        private get messagesNode();
        template(): string | Array<string> | JQuery;
        protected onActivate(e: Jade.UI.ControlEventArgs): void;
    }
}
declare namespace Jade.UI {
    enum MultipleChoiceDialogType {
        Radio = 0,
        Checkbox = 1
    }
    interface IMultipleChoiceDialogResponse extends IMessageDialogResponse {
        selected: Array<IMultipleChoiceDialogItem>;
    }
    interface IMultipleChoiceDialogOptions extends IMessageDialogBaseOptions {
        header: string;
        items: Array<IMultipleChoiceDialogItem>;
        type: MultipleChoiceDialogType;
        select?(e: IMultipleChoiceDialogResponse): void;
    }
    class MultipleChoiceDialog extends MessageDialogBase {
        private m_content;
        constructor(options: IMultipleChoiceDialogOptions, windowOptions?: any);
        private get items();
        private get header();
        private get content();
        static open(options: IMultipleChoiceDialogOptions, windowOptions?: any): MultipleChoiceDialog;
        protected onActivate(e: Jade.UI.ControlEventArgs): void;
        protected getWindowOptions(): any;
        protected select(selectionId: string): void;
    }
}
declare namespace Jade.UI {
    interface IMultipleChoiceDialogContentOptions extends Jade.UI.IControlOptions {
        header: string;
        items: Array<IMultipleChoiceDialogItem>;
    }
    class MultipleChoiceDialogContent extends Jade.UI.Control {
        constructor(options: IMultipleChoiceDialogContentOptions);
        private get itemsArray();
        get items(): Jade.Collection<MultipleChoiceDialogItem>;
        private get header();
        template(): string | Array<string> | JQuery;
        protected onActivate(e: Jade.UI.ControlEventArgs): void;
    }
}
declare namespace Jade.UI {
    interface IMultipleChoiceDialogItemOptions extends Jade.UI.IControlOptions {
        title: string;
        message: string;
        selected: boolean;
        value: any;
        group: string;
    }
    interface IMultipleChoiceDialogItem {
        title: string;
        message: string;
        selected?: boolean;
        value: any;
    }
    class MultipleChoiceDialogItem extends Jade.UI.Control {
        constructor(options: IMultipleChoiceDialogItemOptions);
        private get title();
        private get message();
        private get group();
        private get selected();
        private get value();
        private get inputNode();
        template(): string | Array<string> | JQuery;
        toJSON(): IMultipleChoiceDialogItem;
        isSelected(): boolean;
        protected onActivate(e: Jade.UI.ControlEventArgs): void;
    }
}
declare namespace Jade.UI {
    class TaskDialog extends Dialog {
        private m_notificationDialog;
        private m_notificationDialogTypes;
        private m_status;
        constructor(options: any);
        private get notificationDialog();
        private set notificationDialog(value);
        private get notificationDialogTypes();
        private set notificationDialogTypes(value);
        protected get btnClose(): JQuery;
        protected get btnCancel(): JQuery;
        protected get btnDetail(): JQuery;
        protected get label(): JQuery;
        protected get progress(): JQuery;
        protected get progressBar(): JQuery;
        protected get detail(): JQuery;
        protected get btnDetailLabel(): JQuery;
        private closeButton_onClick;
        private cancelButton_onClick;
        private detailButton_onClick;
        private poll_onSuccess;
        private poll_onError;
        onActivate(e: ControlEventArgs): void;
        onComplete(e: ControlEventArgs): void;
        template(): string | Array<string> | JQuery;
        close(options: any): void;
        getWindowOptions(): any;
        private start;
        private pollStatus;
        private updateStatus;
        private alert;
        private scrollDetailToBottom;
        private showDetail;
        private hideDetail;
        private addLabelMessage;
        private addDetailMessages;
        private addDetailMessage;
        private complete;
        private fatalError;
        private setProgressBar;
        private enableClose;
        private getTaskEventArgs;
        private registerTaskNotificationDialogTypes;
        private showNotificationDialog;
        private sendNotificationResponse;
        private handleNotification;
    }
}
declare namespace Jade.UI {
    interface IToolBarOptions extends IControlOptions {
        segments: Array<ToolBarSegment>;
    }
    class ToolBar extends Control {
        private m_items;
        private m_instance;
        private m_segments;
        constructor(options: IToolBarOptions);
        private get segments();
        private get items();
        get instance(): kendo.ui.ToolBar;
        onInit(e: ControlEventArgs): void;
        onTemplate(e: ControlEventArgs): void;
        onActivate(e: ControlEventArgs): void;
        protected onToggle(e: kendo.ui.ToolBarToggleEvent): void;
        protected onClick(e: kendo.ui.ToolBarClickEvent): void;
        protected onToggleOrClick(id: string): void;
        template(): string | Array<string> | JQuery;
        private addSegments;
        private addItems;
        private iterateItems;
    }
}
declare namespace Jade.UI {
    class ToolBarItemCollection extends Collection<ToolBarItem> {
    }
}
declare namespace Jade.UI {
    class ToolBarItemOnClickEventArgs {
        private m_toolBar;
        private m_item;
        constructor(options: {
            toolBar: ToolBar;
            item: ToolBarItem;
        });
        get toolBar(): ToolBar;
        get item(): ToolBarItem;
    }
}
declare namespace Jade.UI {
    class ToolBarItemOnCommandChangeEventArgs {
        private m_toolbar;
        private m_node;
        private m_command;
        private m_context;
        constructor(options: {
            toolbar: ToolBar;
            node: JQuery;
            command: Command;
            context: Context;
        });
        get toolbar(): ToolBar;
        get node(): JQuery;
        get command(): Command;
        get context(): Context;
    }
}
declare namespace Jade.UI {
    class ToolbarOnRefreshEventArgs {
        private m_item;
        private m_toolbar;
        private m_context;
        private m_node;
        constructor(options: {
            item: ToolBarItem;
            toolbar: ToolBar;
            context: any;
            node: JQuery;
        });
        get item(): ToolBarItem;
        get toolbar(): ToolBar;
        get context(): any;
        get node(): JQuery;
        enabled(value: boolean): void;
        visible(value: boolean): void;
    }
}
declare namespace Jade.UI {
    class ToolBarSegment {
        private m_oldContext;
        private m_newContext;
        private m_items;
        constructor(context?: any);
        protected get oldContext(): any;
        protected get context(): any;
        get items(): ToolBarItemCollection;
        onAddItems(e: ToolbarOnAddItemsEventArgs): void;
        protected onRefresh(e: any): void;
        protected onClick(e: ToolBarItemOnClickEventArgs): void;
        meetsLoadConditions(e: any): boolean;
        refresh(e: any): void;
        click(e: ToolBarItemOnClickEventArgs): void;
    }
}
declare namespace Jade.UI {
    class ToolbarOnAddItemsEventArgs {
        private m_toolBar;
        private m_items;
        private m_segment;
        constructor(options: {
            toolBar: ToolBar;
            items: ToolBarItemCollection;
            segment: ToolBarSegment;
        });
        protected get toolBar(): ToolBar;
        protected get items(): ToolBarItemCollection;
        get segment(): ToolBarSegment;
        registerItem(item: ToolBarItem): void;
    }
}
declare namespace Jade.UI {
    class ToolBarItem {
        private m_state;
        private m_toolBar;
        constructor(options?: any);
        protected onInit(e?: any): void;
        protected onLoad(e?: any): void;
        protected onActivate(e?: any): void;
        protected onComplete(e?: any): void;
        protected onClick(e: ToolBarItemOnClickEventArgs): void;
        get ID(): string;
        get state(): StateBag;
        get toolbar(): ToolBar;
        set toolbar(value: ToolBar);
        get node(): JQuery;
        click(e: ToolBarItemOnClickEventArgs): void;
        toJSON(): any;
        activate(e?: any): void;
        refresh(e: any): void;
        protected setDefaultOptions(): any;
    }
}
declare namespace Jade.UI {
    interface IToolBarItemCommandOptions {
        commandId: string;
    }
    class ToolBarItemCommand extends ToolBarItem {
        private m_label;
        private m_icon;
        private m_tooltip;
        private m_visible;
        private m_enabled;
        private m_value;
        constructor(options: any);
        protected get commandId(): string;
        protected get commandSubscriber(): CommandSubscriber;
        protected set commandSubscriber(value: CommandSubscriber);
        get label(): string;
        get icon(): string;
        get display(): string;
        get enabled(): boolean;
        get tooltip(): boolean;
        get visible(): boolean;
        get value(): any;
        protected onInit(e?: any): void;
        toJSON(): any;
        click(e: ToolBarItemOnClickEventArgs): void;
        refresh(): void;
        protected template(): string | Array<string> | JQuery;
        protected onPropertiesChanged(): void;
        protected getValue(id: string, defaultValue: any): any;
    }
}
declare namespace Jade.UI {
    class ToolBarButtonCommand extends ToolBarItemCommand {
        constructor(options: IToolBarItemCommandOptions);
        get command(): Command;
        protected onActivate(e: ControlEventArgs): void;
        protected onPropertiesChanged(): void;
        toJSON(): any;
        protected template(e?: ToolBarItemOnCommandChangeEventArgs): string;
        private showIcon;
        private showLabel;
        private getCssClass;
    }
}
declare namespace Jade.UI.Controls {
    interface IShowContextMenuArgs extends IContextMenuPosition {
        groups: Array<string>;
        parent?: ContextMenu;
    }
    interface IContextMenuPosition {
        x: number;
        y: number;
    }
    export interface IContextMenuOptions extends IControlOptions {
        onHide?: Function;
    }
    export class ContextMenu extends Control {
        private m_parent;
        private m_visible;
        private m_x;
        private m_y;
        private m_items;
        private m_groups;
        constructor(options: IContextMenuOptions);
        get items(): MappedCollection<ContextMenuItem>;
        get groups(): MappedCollection<ContextMenuGroup>;
        get attachTo(): JQuery;
        get parent(): ContextMenu;
        get x(): number;
        get y(): number;
        get visible(): boolean;
        protected onTemplate(e: ControlEventArgs): void;
        template(): string | Array<string> | JQuery;
        show(e: IShowContextMenuArgs): void;
        hide(): void;
        private getPosition;
        private showGroups;
    }
    export {};
}
declare namespace Jade.UI.Controls {
    class ContextMenuItemBase extends Control {
        private m_parent;
        get parent(): ContextMenu;
        set parent(value: ContextMenu);
        template(): string | Array<string> | JQuery;
        click(e: JQueryEventObject): void;
        refresh(): void;
    }
}
declare namespace Jade.UI.Controls {
    class ContextMenuDivider extends ContextMenuItemBase {
        constructor();
        template(): string | Array<string> | JQuery;
    }
}
declare namespace Jade.UI.Controls {
    interface IContextMenuGroupOptions {
        id: string;
    }
    class ContextMenuGroup {
        private m_id;
        private m_items;
        constructor(options: IContextMenuGroupOptions);
        get ID(): string;
        get items(): Collection<ContextMenuItemBase>;
        hide(contextMenu: ContextMenu): void;
        show(contextMenu: ContextMenu): void;
        protected onPopulate(): void;
        protected meetsLoadConditions(): boolean;
    }
}
declare namespace Jade.UI.Controls {
    class ContextMenuGroups {
        private static m_groups;
        private static get groups();
        static add(group: ContextMenuGroup): void;
        static remove(groupId: string): void;
        static get(groupId: string): ContextMenuGroup;
        static clear(): void;
        static reset(): void;
    }
}
declare namespace Jade.UI.Controls {
    interface IContextMenuItemOptions extends IControlOptions {
        commandId?: string;
        label?: string;
        icon?: string;
        tooltip?: string;
        visible?: boolean;
        enabled?: boolean;
        value?: any;
        closeOnClick?: boolean;
    }
    class ContextMenuItem extends ContextMenuItemBase {
        private m_commandSubscriber;
        private m_label;
        private m_icon;
        private m_tooltip;
        private m_visible;
        private m_enabled;
        private m_value;
        constructor(options: IContextMenuItemOptions);
        get label(): string;
        get icon(): string;
        get enabled(): boolean;
        get tooltip(): boolean;
        get visible(): boolean;
        get value(): any;
        get closeOnClick(): boolean;
        protected get commandSubscriber(): CommandSubscriber;
        template(): string | Array<string> | JQuery;
        click(e: JQueryEventObject): void;
        refresh(): void;
        protected onTemplateStart(e: ControlEventArgs): void;
        protected onTemplateComplete(e: ControlEventArgs): void;
        protected onPropertiesChanged(): void;
        protected onStateChanged(): void;
        protected getValue(id: string, defaultValue: any): any;
    }
}
declare namespace Jade.UI.Controls {
    class ContextMenuItemTemplate extends ContextMenuItem {
        protected onPropertiesChanged(): void;
    }
}
declare namespace Jade.UI.Controls {
    interface IContextMenuItemColorPaletteOptions extends IContextMenuItemOptions {
        commandId?: string;
        palette: Array<string>;
    }
    class ContextMenuItemColorPalette extends ContextMenuItemTemplate {
        private m_palette;
        constructor(options: IContextMenuItemColorPaletteOptions);
        get palette(): kendo.ui.ColorPicker;
        template(): string | Array<string> | JQuery;
        click(e: JQueryEventObject): void;
        protected onActivate(e: ControlEventArgs): void;
        protected onColorSelect(color: string): void;
    }
    class ContextMenuItemColorPalettes {
        static get standardColors(): Array<string>;
        static get themeColors(): Array<string>;
    }
}
declare namespace Jade.UI.Controls {
    interface IContextMenuItemHeaderOptions extends IControlOptions {
        label: string;
    }
    class ContextMenuItemHeader extends ContextMenuItemBase {
        private m_commandSubscriber;
        constructor(options: IContextMenuItemHeaderOptions);
        get label(): string;
        template(): string | Array<string> | JQuery;
    }
}
declare namespace Jade.UI.Controls {
    interface IContextMenuItemSubMenuOptions extends IContextMenuItemOptions {
        commandId?: string;
        menu: Array<string>;
        parent?: ContextMenu;
    }
    class ContextMenuItemSubMenu extends ContextMenuItem {
        private m_mouseIsOverContextMenu;
        private m_mouseIsOverItem;
        private m_contextMenu;
        private m_hasMouseHandlers;
        constructor(options: IContextMenuItemSubMenuOptions);
        protected get contextMenu(): ContextMenu;
        protected set contextMenu(value: ContextMenu);
        protected get menu(): Array<string>;
        get closeOnClick(): boolean;
        template(): string | Array<string> | JQuery;
        click(e: JQueryEventObject): void;
        protected onActivate(e: ControlEventArgs): void;
        private onMouseEnter;
        private contextMenu_onMouseEnter;
        private contextMenu_onMouseLeave;
        protected createContextMenu(): void;
    }
}
declare namespace Jade.UI.Controls {
    interface IRibbonBarOptions {
        contextID: null;
    }
    class RibbonBar extends Control {
        private m_selectedSectionId;
        private m_tabStrip;
        private m_sections;
        private get tabStrip();
        get sections(): MappedCollection<RibbonBarSection>;
        get selectedSectionId(): string;
        protected onInit(e: Jade.UI.ControlEventArgs): void;
        protected onActivate(e: Jade.UI.ControlEventArgs): void;
        protected onTabClick(e: JQueryEventObject): void;
        template(): string | Array<string> | JQuery;
        show(toolingIds: Array<string>): void;
        private selectTab;
        private getFirstSection;
    }
}
declare namespace Jade.UI.Controls {
    interface IRibbonBarGroupOptions extends IControlOptions {
        toolingId: string;
    }
    class RibbonBarGroup extends Control {
        private m_alwaysShow;
        constructor(options: IRibbonBarGroupOptions);
        get label(): string;
        get toolingId(): string;
        get alwaysShow(): boolean;
        template(): string | Array<string> | JQuery;
        protected onPopulate(): void;
        protected onActivateComplete(e: ControlEventArgs): void;
        protected shouldAlwaysShow(value: boolean): void;
    }
}
declare namespace Jade.UI.Controls {
    class RibbonBarGroups {
        private static m_groups;
        private static get groups();
        static add(tab: RibbonBarGroup): void;
        static remove(groupId: string): void;
        static get(groupId: string): RibbonBarGroup;
        static clear(): void;
        static reset(): void;
    }
}
declare namespace Jade.UI.Controls {
    interface IRibbonBarSectionOptions extends IControlOptions {
        label: string;
        toolingId: string;
    }
    class RibbonBarSection extends Control {
        private m_groups;
        constructor(options: IRibbonBarSectionOptions);
        get groups(): MappedCollection<RibbonBarGroup>;
        get label(): string;
        get toolingId(): string;
        get alwaysShow(): boolean;
        template(): string | Array<string> | JQuery;
        show(toolingIds: Array<string>): void;
        protected onPopulate(): void;
    }
}
declare namespace Jade.UI.Controls {
    class RibbonBarSections {
        private static m_sections;
        static get sections(): Jade.MappedCollection<RibbonBarSection>;
        static add(section: RibbonBarSection): void;
        static remove(sectionId: string): void;
        static get(sectionId: string): RibbonBarSection;
        static clear(): void;
        static reset(): void;
    }
}
declare namespace Jade.UI.Controls {
    interface IRibbonBarSetOptions extends IControlOptions {
        width?: number;
        items?: Array<RibbonBarItem>;
    }
    class RibbonBarSet extends Control {
        constructor(options: IRibbonBarSetOptions);
        protected get items(): Array<RibbonBarItem>;
        protected get width(): number;
        template(): string | Array<string> | JQuery;
        protected onPopulate(): void;
        protected onActivateComplete(e: ControlEventArgs): void;
    }
}
declare namespace Jade.UI.Controls {
    interface IRibbonBarTabOptions extends IControlOptions {
        sectionId: string;
        label: string;
    }
    class RibbonBarTab extends Jade.UI.Control {
        get label(): string;
        get sectionId(): string;
        template(): string | Array<string> | JQuery;
    }
}
declare namespace Jade.UI.Controls {
    class RibbonBarTabStrip extends Jade.UI.Control {
        get tabs(): IReadOnlyCollection<RibbonBarTab>;
        template(): string | Array<string> | JQuery;
        getTabBySectionId(sectionId: string): RibbonBarTab;
    }
}
declare namespace Jade.UI.Controls {
    class RibbionFluid {
        get contractions(): number;
        contract(): void;
        expand(): void;
        canContract(): boolean;
        canExpand(): boolean;
    }
    class RibbonFluidPriority {
        get priority1(): number;
        get priority2(): number;
        get priority3(): number;
        get priority4(): number;
        get priority5(): number;
    }
}
declare namespace Jade.UI.Controls {
    interface IRibbonBarItemOptions extends IControlOptions {
        commandId?: string;
        menu?: Array<string>;
        label?: string;
        icon?: string;
        tooltip?: string;
        visible?: boolean;
        enabled?: boolean;
    }
    class RibbonBarItem extends Jade.UI.Control {
        private m_commandSubscriber;
        private m_contextMenu;
        private m_label;
        private m_icon;
        private m_tooltip;
        private m_visible;
        private m_enabled;
        private m_value;
        constructor(options: IRibbonBarItemOptions);
        get label(): string;
        get icon(): string;
        get enabled(): boolean;
        set enabled(value: boolean);
        get tooltip(): boolean;
        get visible(): boolean;
        get value(): any;
        protected get contextMenu(): ContextMenu;
        protected set contextMenu(value: ContextMenu);
        protected get menu(): Array<string>;
        protected get commandSubscriber(): CommandSubscriber;
        click(e: JQueryEventObject): void;
        protected onActivate(e: Jade.UI.ControlEventArgs): void;
        protected onTemplateStart(e: ControlEventArgs): void;
        protected onTemplateComplete(e: ControlEventArgs): void;
        protected onPropertiesChanged(): void;
        protected wrapTemplate(template: JQuery): JQuery;
        protected createContextMenu(): void;
        protected getValue(id: string, defaultValue: any): any;
    }
}
declare namespace Jade.UI.Controls {
    class RibbonBarToggle extends RibbonBarItem {
        click(e: JQueryEventObject): void;
    }
}
declare namespace Jade.UI.Controls {
    interface IRibbonBarButtonOptions extends IRibbonBarItemOptions {
        width?: number;
    }
    class RibbonBarButton extends RibbonBarItem {
        constructor(options: IRibbonBarButtonOptions);
        private get labelNode();
        private get imageNode();
        get icon(): string;
        get width(): number;
        protected onPropertiesChanged(): void;
        protected onActivate(e: Jade.UI.ControlEventArgs): void;
        template(): string | Array<string> | JQuery;
        private getLabel;
        private setWidth;
    }
}
declare namespace Jade.UI.Controls {
    class RibbonBarButtonSmall extends RibbonBarItem {
        get icon(): string;
        template(): string | Array<string> | JQuery;
    }
}
declare namespace Jade.UI.Controls {
    class RibbonBarList extends RibbonBarItem {
    }
}
declare namespace Jade.UI.Controls {
    class RibbonBarToggleButton extends Control {
    }
}
declare namespace Jade.UI.Controls {
    interface IToolingControl {
        tooling: Tooling;
    }
    class Tooling {
        private m_set;
        add(tag: string): void;
        remove(tag: string): void;
        clear(): void;
        contains(tag: string): boolean;
        toArray(): Array<string>;
        static getCommon(toolings: Array<Tooling>): Array<string>;
    }
    function toolingTags<TTarget extends Control>(...tags: Array<string>): <T extends new (...args: any[]) => {}>(constr: T) => {
        new (...args: any[]): {};
    } & T;
}
