declare namespace Jade {
    interface IEventBusOptions {
        label: string;
    }
    class EventBus {
        private m_id;
        private m_label;
        private m_events;
        constructor(options?: IEventBusOptions);
        get id(): string;
        get label(): string;
        private get events();
        subscribe(eventType: string, callback: Function): EventBusSubscription;
        publish(eventType: string, data?: any): void;
        clear(): void;
    }
}
declare namespace Jade {
    class ContextEventBus extends EventBus {
    }
}
declare namespace Jade {
    interface ISetStateOptions {
        overwrite?: boolean;
        force?: boolean;
    }
    class CommandContext {
        m_id: string;
        m_groups: CommandGroupCollection;
        constructor(options: any);
        get ID(): string;
        get groups(): CommandGroupCollection;
        setState(state: any, options?: ISetStateOptions): void;
        ensureGroup(groupId: string): CommandGroup<ICommandState>;
        resolve(commandPath: string): ICommandInfo;
        execute(commandPath: string, args?: any): void;
        clear(): void;
    }
}
declare namespace Jade {
    interface IContextFocusEventArgs {
        isCurrent: boolean;
    }
    class Context {
        static CONTEXT_FOCUS_EVENT: string;
        private m_options;
        private m_events;
        private m_commands;
        private m_store;
        private m_hotkeys;
        private m_depth;
        private m_tags;
        private m_node;
        constructor(options: IContextOptions);
        get ID(): string;
        get name(): string;
        get options(): StateBag;
        get parent(): Context;
        get commands(): CommandContext;
        get events(): ContextEventBus;
        get tags(): Array<string>;
        get hotkeys(): Keypress.Listener;
        get store(): StateBag;
        get depth(): number;
        get node(): any;
        get isDialogContext(): boolean;
        onCurrentChanged(current: boolean): void;
        destroy(): void;
        findClosestContext(tags: Array<string>, matchAny?: boolean): Context;
        isCurrent(value: boolean): void;
        private isTaggedWith;
    }
}
declare namespace Jade {
    class ContextCollection {
        private m_collection;
        private m_options;
        private m_childContextMaps;
        constructor(options: any);
        get options(): StateBag;
        add(context: Context): void;
        remove(context: Context | string, destroyChildContexts?: boolean): void;
        each(fn: Function): void;
        exists(context: Context | string): boolean;
        getById(contextId: string): Context;
        private getContextId;
        private createChildContextMap;
        private destroyChildContexts;
    }
}
declare namespace Jade {
    interface IContextOptions {
        id?: string;
        name?: string;
        parent?: Context;
        makeDefault?: boolean;
        isDialogContext?: boolean;
        contextNode?: any;
    }
    interface IContextChangedCallback {
        (e: IContextChangedEventArgs): void;
    }
    interface IDestroyContextArgs {
        id?: string;
    }
    interface IContextChangedEventArgs {
        oldContextId: string;
        newContextId: string;
        oldContext: Context;
        newContext: Context;
    }
    interface IRevolveContextArgs {
        context?: Context;
        fn: () => void;
        tags?: Array<string>;
    }
    class ContextManager {
        private GLOBAL_CONTEXT_ID;
        private m_globalContext;
        private m_currentContext;
        private m_contexts;
        private static m_onContextChangeCallbacks;
        constructor();
        get contexts(): ContextCollection;
        get current(): Context;
        get global(): Context;
        setCurrent(contextId: string): void;
        createContext(createOptions: IContextOptions): Context;
        destroyContext(options: IDestroyContextArgs): void;
        revolveContext(args: IRevolveContextArgs): void;
        getContextById(contextId: any): Context;
        findClosestContext(tagsArr: any): Context;
        private isCurrent;
        static onContextChange(callback: IContextChangedCallback): void;
        static setTimeout(callback: Function, timeout?: number): void;
    }
}
declare namespace Jade {
    const nameof: <T>(name: Extract<keyof T, string>) => string;
    interface IApplicationOptions {
        virtualDirectory: string;
        name: string;
        label: string;
    }
    class Application {
        private static m_instance;
        private static m_hasStarted;
        private static m_startFunctions;
        private m_options;
        private m_contexts;
        private m_id;
        constructor(options: IApplicationOptions);
        get id(): string;
        set id(value: string);
        static get instance(): Application;
        protected static get internalInstance(): Application;
        protected static set internalInstance(value: Application);
        static get hasStarted(): boolean;
        get name(): string;
        get virtualDirectory(): string;
        get imagePaths(): {
            [key: string]: string;
        };
        get contexts(): ContextManager;
        get options(): StateBag;
        static onStart(callback: () => void): void;
        protected onInit(options: IApplicationOptions): void;
        private executeStartUpFunctions;
        private captureBrowserResizeEvent;
    }
}
declare namespace Jade {
    class Arithmetic {
        static round(number: number, roundToNearest: number): number;
        static roundUp(number: number, roundToNearest: number): number;
        static roundDown(number: number, roundToNearest: number): number;
        static randomInteger(min: number, max: number): number;
    }
}
declare namespace Jade {
    class Attribute {
        protected static get root(): string;
        protected get name(): string;
        protected static define(callback: (context: any) => void): Function;
    }
}
declare namespace Jade {
    enum DiskUnits {
        Bytes = 0,
        KB = 1,
        MB = 2,
        GB = 3,
        TB = 4
    }
    class Convert {
        static BytesToUnits(bytes: number, roundUnitsUnder?: DiskUnits): string;
    }
}
declare namespace Jade {
    class Enum {
        static GetNames(enumeration: any): string[];
        static GetValues(enumeration: any): Array<any>;
        static GetName(enumeration: any, value: any): string;
    }
}
declare namespace Jade {
    enum HttpVerb {
        GET = "GET",
        DELETE = "DELETE",
        POST = "POST",
        PUT = "PUT"
    }
    enum BrowserEvent {
        CLICK = "click",
        CHANGE = "change",
        DOUBLECLICK = "dblclick",
        MOUSEDOWN = "mousedown",
        MOUSEUP = "mouseup",
        MOUSEOVER = "mouseover",
        MOUSEENTER = "mouseenter",
        MOUSELEAVE = "mouseleave",
        KEYDOWN = "keydown",
        KEYUP = "keyup",
        KEYPRESS = "keypress",
        RESIZE = "resize",
        FOCUS = "focus",
        BLUR = "blur",
        SCROLL = "scroll"
    }
}
declare namespace Jade {
    class EventMap {
        private m_map;
        fire(eventName: string, ...args: any): void;
        add(eventName: any, fn: Function): void;
        private hasKey;
        private ensureKey;
        private addHandler;
        private handlers;
    }
}
declare namespace Jade {
    class Events {
        static get BrowserResizedEvent(): string;
        static get BrowserFocusedEvent(): string;
    }
}
declare namespace Jade {
    class Guid {
        static new(): string;
        static empty(): string;
        static isGuid(value: string): boolean;
        static isNullOrEmpty(value: string): boolean;
    }
}
declare namespace Jade {
    interface IDictionary {
        [key: string]: any;
    }
}
declare namespace Jade {
    enum IconSetSizeSpecificDirectory {
        x16 = "16x16",
        x24 = "24x24",
        x32 = "32x32",
        x48 = "48x48",
        x64 = "64x64",
        x128 = "128x128",
        x256 = "256x256",
        x512 = "512x512",
        misc = "misc"
    }
    interface IIconSet {
        id: string;
        rootPath: string;
    }
    interface IIconSetList {
        [key: string]: IconSet;
    }
    class IconSet {
        private static m_list;
        private m_options;
        private constructor();
        get ID(): string;
        get rootPath(): string;
        private get options();
        resolve(icon: string, sizeSpecificDirectory: IconSetSizeSpecificDirectory): string;
        static add(data: IIconSet): void;
        static get(id: string): IconSet;
        static remove(id: string): void;
    }
}
declare namespace Jade {
    class Instance {
        static isEmptyObject(item: any): boolean;
    }
}
declare namespace Jade {
    interface IInterfaceGuard {
        signature: IInterfaceSignature;
    }
    interface IInterfaceSignature {
        id: string;
        label: string;
    }
    interface IInterfaceRegistration {
        instance: any;
        guard: InterfaceGuard;
    }
    interface IInterfaceGuardType {
        new (...args: any[]): InterfaceGuard;
    }
    abstract class InterfaceGuard implements IInterfaceGuard {
        abstract get signature(): IInterfaceSignature;
        protected static get root(): string;
        static is(target: any, ...guards: IInterfaceGuardType[]): boolean;
        static isAny(target: any, ...guards: IInterfaceGuardType[]): boolean;
        static anyImplement(targets: Array<any>, type: IInterfaceGuardType): boolean;
        static allImplement(targets: Array<any>, type: IInterfaceGuardType): boolean;
        static register(registration: IInterfaceRegistration): void;
        static implement(...guards: IInterfaceGuardType[]): Function;
        protected static define(callback: (context: any) => void): Function;
        protected static iterateGuards(guards: IInterfaceGuardType[], callback: (guard: InterfaceGuard) => void): void;
        private static hasInterfaces;
        private static hasInterface;
    }
}
declare namespace Jade {
    class Json {
        static tryParse(target: string): any;
        static parse(target: string): any;
        static stringify(target: any): void;
    }
}
declare namespace Jade {
    enum KeyCode {
        Backspace = 8,
        Tab = 9,
        Enter = 13,
        Shift = 16,
        Ctrl = 17,
        Alt = 18,
        Pause = 19,
        CapsLock = 20,
        Escape = 27,
        Space = 32,
        End = 35,
        Home = 36,
        ArrowLeft = 37,
        ArrowUp = 38,
        ArrowRight = 39,
        ArrowDown = 40,
        Insert = 45,
        Delete = 46,
        Key0 = 48,
        Key1 = 49,
        Key2 = 50,
        Key3 = 51,
        Key4 = 52,
        Key5 = 53,
        Key6 = 54,
        Key7 = 55,
        Key8 = 56,
        Key9 = 57,
        KeyA = 65,
        KeyB = 66,
        KeyC = 67,
        KeyD = 68,
        KeyE = 69,
        KeyF = 70,
        KeyG = 71,
        KeyH = 72,
        KeyI = 73,
        KeyJ = 74,
        KeyK = 75,
        KeyL = 76,
        KeyM = 77,
        KeyN = 78,
        KeyO = 79,
        KeyP = 80,
        KeyQ = 81,
        KeyR = 82,
        KeyS = 83,
        KeyT = 84,
        KeyU = 85,
        KeyV = 86,
        KeyW = 87,
        KeyX = 88,
        KeyY = 89,
        KeyZ = 90,
        Pad0 = 96,
        Pad1 = 97,
        Pad2 = 98,
        Pad3 = 99,
        Pad4 = 100,
        Pad5 = 101,
        Pad6 = 102,
        Pad7 = 103,
        Pad8 = 104,
        Pad9 = 105,
        PadMultiply = 106,
        PadAdd = 107,
        PadSubtract = 109,
        PadPoint = 110,
        PadDivide = 111,
        F01 = 112,
        F02 = 113,
        F03 = 114,
        F04 = 115,
        F05 = 116,
        F06 = 117,
        F07 = 118,
        F08 = 119,
        F09 = 120,
        F10 = 121,
        F11 = 122,
        F12 = 123,
        NumLock = 144,
        ScrollLock = 145,
        SemiColon = 186,
        EqualSign = 187,
        Comma = 188,
        Dash = 189,
        Period = 190,
        ForwardSlash = 191,
        GraveAccent = 192,
        OpenBracket = 219,
        BackSlash = 220,
        CloseBracket = 221,
        SingleQuote = 222
    }
}
declare namespace Jade {
    class LocalStorage {
        private static m_eventListener;
        private static m_events;
        static get(key: string): string;
        static getOf<T>(key: string): T;
        static set(key: string, value: any): any;
        static exists(key: string): boolean;
        static subscribe(eventName: string, fn: Function): void;
        private static ensureListener;
    }
}
declare namespace Jade {
    class Path {
        static resolve(path: string, qs?: any): string;
        static resolveImage(name: string, imagePathId: string): string;
        static addIconSet(path: string, imagePathId: string): void;
        static getFileNameWithoutExtension(path: string): string;
        static getFileExtension(path: string): string;
        static isVirtual(path: string): boolean;
    }
}
declare namespace Jade {
    interface DeepModel {
        new (options?: any): Backbone.Model;
    }
    const StateBag_base: DeepModel;
    export class StateBag extends StateBag_base {
        private m_doNotSerialize;
        constructor(options?: any);
        get doNotSerialize(): Collection<string>;
        get(id: string, defaultValue?: any): any;
        set(obj: any, options?: Backbone.ModelSetOptions): any;
        set(id: string, value?: any, options?: Backbone.ModelSetOptions): any;
        replace(obj: any, options?: Backbone.ModelSetOptions): void;
        update(obj: any, options?: Backbone.ModelSetOptions): void;
        update(id: any, value?: any, options?: Backbone.ModelSetOptions): void;
        add(id: string, value: any): void;
        extend(...items: any[]): any;
        toJSON(options?: any): any;
    }
    export {};
}
declare namespace Jade {
    class Store<T> {
        private m_dictionary;
        set(item: any): void;
        get(key: any): T;
        remove(key: any): void;
        private hasKey;
        private getUid;
    }
}
declare namespace Jade {
    interface ITitleCaseOptions {
        lowers?: Array<string>;
        uppers?: Array<string>;
    }
    class String {
        static template(value: Array<string>): string;
        static format(text: string, ...params: string[]): string;
        static isNullOrWhiteSpace(value: string): boolean;
        static startsWith(value: string, searchText: string, caseInsensitive?: boolean): boolean;
        static toTitleCase(text: string, options?: ITitleCaseOptions): string;
        static padLeft(value: string, padWith: string, padCount?: number): string;
    }
}
declare namespace Jade {
    class Type {
        static getType(name: string): any;
    }
}
declare namespace Jade {
    interface IReadOnlyCollection<T> {
        contains(item: T): boolean;
        each(callback: Function): void;
        first(): T;
        item(index: number): T;
        indexOf(item: T): number;
        last(): T;
        toArray(): Array<T>;
        transform(callback: Function): Array<T>;
        count: number;
    }
    interface ICollection<T> {
        count: number;
        add(item: T): boolean;
        addRange(items: Array<T>): void;
        contains(item: T): boolean;
        clear(): void;
        each(callback: Function): void;
        first(): T;
        item(index: number): T;
        indexOf(item: T): number;
        insert(item: T, index: number): any;
        insertRange(items: Array<T>, insertIndex?: number): any;
        move(item: T, index: number): void;
        last(): T;
        remove(item: T): T;
        removeAt(index: any): T;
        reverse(): void;
        reverseCopy(): ICollection<T>;
        sort(fn: (item1: T, item2: T) => number): void;
        toArray(): Array<T>;
        transform(callback: Function): Array<any>;
    }
    class Collection<T> implements ICollection<T> {
        private m_innerList;
        constructor(data?: Array<T> | T);
        protected get innerList(): Array<T>;
        get count(): number;
        protected onChange(): void;
        add(item: T): boolean;
        addRange(items: Array<T>): void;
        contains(item: T): boolean;
        clear(): void;
        each(callback: (item: T, index?: number) => any): void;
        first(): T;
        item(index: number): T;
        indexOf(item: T): number;
        insert(item: T, index: number): boolean;
        insertRange(items: Array<T>, insertIndex?: number): void;
        move(item: T, index: number): void;
        last(): T;
        remove(item: T): T;
        removeAt(index: any): T;
        private removeAtIndices;
        reverse(): void;
        reverseCopy(): ICollection<T>;
        sort(fn: (item1: T, item2: T) => number): void;
        toArray(): Array<T>;
        transform(callback: Function): Array<any>;
        getByType<T1 extends T>(type: {
            new (...args: any[]): T1;
        }): Collection<T1>;
    }
}
declare namespace Jade {
    interface IMappedCollectionOptions<T> {
        key: string;
        data?: Array<T> | T;
    }
    interface IReadOnlyMappedCollection<T> extends IReadOnlyCollection<T> {
        get: (id: string) => T;
    }
    interface IMap<T> {
        [key: string]: T;
    }
    class MappedCollection<T> extends Collection<T> {
        private m_map;
        private m_key;
        constructor(options: IMappedCollectionOptions<T>);
        protected get map(): IMap<T>;
        get key(): string;
        add(item: T): boolean;
        contains(item: T): boolean;
        clear(): void;
        get(id: string): T;
        insert(item: T, index: number): boolean;
        removeAt(index: any): T;
        reverseCopy(): ICollection<T>;
    }
}
declare namespace Jade {
    class ObservableCollection<T> extends Collection<T> {
        private m_callbacks;
        constructor(data?: Array<T> | T, callbacks?: IObservableCollectionEventCallbacks<T>);
        add(item: T): boolean;
        insert(item: T, index: number): boolean;
        removeAt(index: number): T;
        clear(): void;
        protected executeChange(event: String, item: T, index: number, operation: Function): void;
        private trigger;
    }
    interface IObservableCollectionEventCallbacks<T> {
        onBeforeAdd?(e: ObservableCollectionBeforeChangeEventArgs<T>): void;
        onBeforeChange?(e: ObservableCollectionBeforeChangeEventArgs<T>): void;
        onBeforeInsert?(e: ObservableCollectionBeforeChangeEventArgs<T>): void;
        onBeforeRemove?(e: ObservableCollectionBeforeChangeEventArgs<T>): void;
        onAfterAdd?(e: ObservableCollectionChangeEventArgs<T>): void;
        onAfterInsert?(e: ObservableCollectionChangeEventArgs<T>): void;
        onAfterRemove?(e: ObservableCollectionChangeEventArgs<T>): void;
        onAfterChange?(e: ObservableCollectionChangeEventArgs<T>): void;
    }
}
declare namespace Jade {
    class ObservableCollectionChangeEventArgs<T> implements IObservableCollectionChangeEventArgs<T> {
        private m_type;
        private m_item;
        private m_index;
        constructor(type: string, item: T, index: number);
        get type(): string;
        get item(): T;
        get index(): number;
    }
    class ObservableCollectionBeforeChangeEventArgs<T> extends ObservableCollectionChangeEventArgs<T> {
        private m_canceled;
        constructor(type: string, item: T, index: number);
        get canceled(): boolean;
        cancel(): void;
    }
    interface IObservableCollectionChangeEventArgs<T> {
        type: string;
        item: T;
        index: number;
    }
}
declare namespace Jade {
    interface IObservableMappedCollectionOptions<T> extends IMappedCollectionOptions<T> {
        callbacks?: IObservableCollectionEventCallbacks<T>;
    }
    class ObservableMappedCollection<T> extends MappedCollection<T> {
        private m_callbacks;
        constructor(options: IObservableMappedCollectionOptions<T>);
        add(item: T): boolean;
        insert(item: T, index: number): boolean;
        removeAt(index: number): T;
        clear(): void;
        protected executeChange(event: String, item: T, index: number, operation: Function): void;
        private trigger;
    }
}
declare namespace Jade {
    class Command {
        private m_props;
        private m_state;
        private m_iconSet;
        private m_uid;
        constructor(props?: ICommandProps);
        get UID(): string;
        get ID(): string;
        get state(): StateBag;
        get props(): StateBag;
        get checked(): boolean;
        set checked(value: boolean);
        get label(): string;
        set label(value: string);
        get enabled(): boolean;
        set enabled(value: boolean);
        get visible(): boolean;
        set visible(value: boolean);
        get icon(): string;
        set icon(value: string);
        get tooltip(): string;
        set tooltip(value: string);
        get display(): string;
        set display(value: string);
        get value(): any;
        set value(value: any);
        private get iconSet();
        protected onInit(): void;
        protected onStateChanged(state: any): void;
        onExecute(e: any): void;
        protected onExecuteSuccess(): void;
        protected onExecuteError(): void;
        protected onExecuteComplete(): void;
        execute(e?: any): void;
        bind(callback: Function): void;
        setState(state: any, options?: ISetStateOptions): void;
        getIcon(size?: IconSetSizeSpecificDirectory, icon?: string): string;
        protected getDefaultValuesForProps(): any;
        private setDefaultValuesForProps;
        private mergeCallbacks;
        private mergeCallback;
        private ensureIconSet;
    }
}
declare namespace Jade {
    class CommandCollection {
        private m_collection;
        constructor(options?: any);
        add(command: Command): void;
        remove(commandId: string): void;
        each(callback: Function): void;
        getByPath(commandPath: string): Command;
        getById(commandId: string): Command;
        private commandIsValid;
        private commandIsRegistered;
    }
}
declare namespace Jade {
    class CommandExecutor {
        execute(command: Command, args?: any): void;
    }
}
declare namespace Jade {
    interface ICommandState {
        [key: string]: any;
    }
    class CommandGroup<T extends ICommandState> implements ICommandGroup {
        m_id: string;
        m_label: string;
        m_visible: boolean;
        m_enabled: boolean;
        m_groupConditionCheck: boolean;
        m_commands: CommandCollection;
        m_executor: CommandExecutor;
        constructor(id: string);
        get ID(): string;
        get label(): string;
        get commands(): CommandCollection;
        protected get executor(): CommandExecutor;
        protected set executor(value: CommandExecutor);
        setState(state: T, options?: ISetStateOptions): void;
        execute(commandPath: string, args: any): void;
        protected onStateChange(state: any, options?: ISetStateOptions): void;
        protected registerCommands(e: OnRegisterCommandsEventArgs): void;
        protected getCommandExecutor(): CommandExecutor;
        private ensureCommandExecutor;
    }
}
declare namespace Jade {
    class CommandGroupCollection {
        m_collection: {
            [key: string]: CommandGroup<ICommandState>;
        };
        constructor();
        each(callback: Function): void;
        add(group: CommandGroup<ICommandState>): void;
        remove(id: string): void;
        groupIsValid(group: CommandGroup<ICommandState>): boolean;
        groupIsDefined(id: string): boolean;
        getByPath(commandPath: string): CommandGroup<ICommandState>;
        getById(groupId: string): CommandGroup<ICommandState>;
        clear(): void;
    }
}
declare namespace Jade {
    class CommandGroups {
        private static m_resgistrations;
        private static m_instances;
        static get registrations(): {
            [key: string]: ICommandGroup;
        };
        static get instances(): {
            [key: string]: ICommandGroup;
        };
        static add(commandGroup: ICommandGroup): void;
        static remove(id: string): void;
        static create(groupId: string): CommandGroup<ICommandState>;
        static get(groupId: string): CommandGroup<ICommandState>;
        static isGroupRegistered(groupId: any): boolean;
    }
}
declare namespace Jade {
    class ICommandInfo {
        context: CommandContext;
        group: CommandGroup<ICommandState>;
        command: Command;
        path: string;
    }
}
declare namespace Jade {
    class CommandPathInfo {
        m_contextId: string;
        m_groupId: string;
        m_commandId: string;
        m_path: string;
        constructor(path: string);
        get contextId(): string;
        get groupId(): string;
        get commandId(): string;
        get path(): string;
        private parse;
    }
}
declare namespace Jade {
    class CommandSubscriber {
        private m_commandId;
        private m_callback;
        private m_subscription;
        get checked(): boolean;
        get label(): string;
        get icon(): string;
        get enabled(): boolean;
        get tooltip(): boolean;
        get visible(): boolean;
        get display(): string;
        get value(): any;
        get command(): Command;
        get info(): ICommandInfo;
        execute(args?: any): void;
        subscribe(commandId: string, callback: Function): void;
        private ensureSubscription;
        private getValue;
    }
}
declare namespace Jade {
    interface ICommandGroup {
    }
}
declare namespace Jade {
    interface ICommandProps {
        id?: string;
        enabled?: boolean;
        icon?: string;
        label?: string;
        tooltip?: string;
        visible?: boolean;
        group?: CommandGroup<ICommandState>;
        iconSetId?: string;
    }
}
declare namespace Jade {
    class OnRegisterCommandsEventArgs {
        private m_commands;
        constructor(options: {
            commands: CommandCollection;
        });
        get commands(): CommandCollection;
    }
}
declare namespace Jade {
    class EventBusCollection {
        m_collection: any;
        constructor();
        add(id: any): void;
        contains(id: any): boolean;
        each(callback: Function): void;
        getById(id: any): any;
        remove(id: any): void;
    }
}
declare namespace Jade {
    class EventBusManager {
        private m_global;
        private m_locals;
        private m_currentLocalId;
        constructor();
        get currentLocalId(): string;
        local(id?: string): EventBus;
        get global(): EventBus;
        setLocal(id: any): void;
        destroy(id: any): void;
    }
}
declare namespace Jade.Data {
    interface ICreateDatabaseArgs {
        db: IDBDatabase;
        request: IDBVersionChangeEvent;
    }
    class Database {
        private m_id;
        private static m_instance;
        private static m_onCreateFunctions;
        constructor(id: string);
        get id(): string;
        static get instance(): Database;
        get connection(): IDBOpenDBRequest;
        static create(id: string): void;
        open(callback: (args: IDBDatabase) => void): void;
        static onCreate(callback: (args: ICreateDatabaseArgs) => void): void;
    }
}
declare namespace Jade.Data {
    interface ITableOptions {
        name: string;
    }
    class Table {
        private m_name;
        constructor(options: ITableOptions);
        get name(): string;
    }
    class TableOf<T> extends Table {
        getOf(id: any, success: (result: T) => void, error?: () => void): void;
        setOf(id: any, value: T, success: () => void, error?: () => void): void;
        delete(id: any, success: () => void, error?: () => void): void;
    }
}
declare namespace Jade {
    class EventBusEvents {
        private m_events;
        constructor();
        private get events();
        publish(eventType: string, data?: any): void;
        subscribe(eventType: any, callback: Function): EventBusSubscription;
        private exists;
        private add;
        private remove;
        private get;
    }
}
declare namespace Jade {
    interface IEventBusSubscriptionOptions {
        subscriptionId: string;
        callback: Function;
        unsubscribe: (subscriptionId: string) => void;
    }
    class EventBusSubscription {
        private m_subscriptionId;
        private m_callback;
        private m_unsubscribeCallback;
        constructor(options: IEventBusSubscriptionOptions);
        private get subscriptionId();
        private get callback();
        private get unsubscribeCallback();
        invoke(data?: any): void;
        unsubscribe(): void;
    }
}
declare namespace Jade {
    interface IEventBusSubscriptionsOptions {
        empty: () => void;
    }
    class EventBusSubscriptions {
        private m_subscriptions;
        private m_emptyCallback;
        constructor(options: IEventBusSubscriptionsOptions);
        private get emptyCallback();
        private get subscriptions();
        publish(data?: any): void;
        subscribe(callback: Function): EventBusSubscription;
        private exists;
        private add;
        private remove;
        private get;
    }
}
