interface DynamicValueConfig {
    type: "raw" | "value";
    content: string;
    value?: string;
    reverse?: boolean;
}
interface DynamicStringConfig {
    templates: DynamicValueConfig[];
}
interface DynamicPropertyConfig extends DynamicStringConfig {
    name: string;
}
declare type DOMEventInfo = {
    name: string;
    bubble: boolean;
    target?: string[];
};
declare type ElementConfigProperties = {
    [index: string]: DynamicPropertyConfig | string;
};
declare type DynamicProperties = {
    [index: string]: DynamicPropertyConfig;
};
declare type WidgetEventHandler = {
    (e: Event): void;
};
declare type WidgetTemplate = string | HTMLElement | {
    (): string | HTMLElement;
};
interface WidgetEnhancedEvent extends Event {
    capture?: {
        (): void;
    };
    bubblingTarget: HTMLElement;
}
declare type Slot = {
    name: string;
    el: Element | Text;
};
declare namespace Leaf {
    interface PropertyDefination<T> {
        get?: (cache: PropertyCache<T>) => T;
        set?: (value: T, cache: PropertyCache<T>) => void;
        value?: T;
    }
    interface PropertyCache<T> {
        [index: string]: any;
        value?: T;
    }
    class Property {
        static define<T>(who: any, name: string, def: PropertyDefination<T>): T;
        static with(who: any): WithProperty<{}>;
    }
    class WithProperty<T> {
        who: any;
        constructor(who: any);
        define<T>(name: string, def: PropertyDefination<T>): this;
    }
}
declare namespace Leaf {
    class Util {
        constructor();
        static clone<T>(obj: T): T;
        static capitalize(str: string): string;
        static uncapitalize(str: string): string;
        static camelToSlug(str: string): string;
        static slugToCamel(str: string): string;
        static deepEqual(a: any, b: any): boolean;
        static arrayDiff<T>(arr1?: T[], arr2?: T[], identical?: (a: T, b: T) => boolean): {
            left: T[];
            right: T[];
            interact: T[];
        };
        static getBrowserInfo(): BrowserInfo;
        static isMobile(): boolean;
        static browser: BrowserInfo;
    }
    interface BrowserInfo {
        name: string;
        version: string;
        mobile: boolean;
    }
}
declare namespace Leaf {
    type StringFunction = (name: string) => string;
    function renderString(str: string, actions: {
        [index: string]: string | StringFunction;
    }): string;
    function render<T>(obj: T, actions: {
        [index: string]: string | StringFunction;
    }): T;
}
declare namespace Leaf {
    interface EventHandlerInfo {
        owner?: any;
        once?: boolean;
        handler: Function;
    }
    interface EventHandlers {
        [index: string]: EventHandlerInfo[];
    }
    class EventEmitter<E extends string> {
        private events;
        constructor();
        addEventListener(event: E, handler: Function): this;
        on(event: E, handler: Function): this;
        once(event: E, handler: Function): this;
        listenByOnce(who: any, event: E, handler: Function): this;
        listenBy(who: any, event: E | E[], handler: Function): this;
        stopListenBy(who: any, event?: E, handler?: Function): this;
        removeEventListener(event?: E, handler?: Function): this;
        emit(event: E, ...values: any[]): this;
        private getOrCreateEventHandlers(event);
    }
}
declare namespace Leaf {
    type TStateDefaultEnum = "void" | "panic";
    class States<TStateEnum, TSignalEnum extends string> {
        events: EventEmitter<string>;
        state: TStateEnum | TStateDefaultEnum;
        previousState: TStateEnum | TStateDefaultEnum;
        private sole;
        private soleEmitted;
        private lastException;
        private rescues;
        protected data: any;
        private feeds;
        private isDebugging;
        private clearHandler;
        readonly name: string;
        panicError: Error;
        panicState: TStateEnum | TStateDefaultEnum;
        constructor();
        reset(): void;
        setState(state: TStateEnum | TStateDefaultEnum, ...args: any[]): void;
        private _stateFinish();
        protected clearConsumers(): void;
        private _setState(state, ...args);
        error(err: Error): void;
        protected atPanic(): void;
        recover(recoverState?: TStateEnum | TStateDefaultEnum): {
            error: Error;
            state: TStateEnum | "void" | "panic";
        };
        respawn(): void;
        clear(handler?: {
            (): void;
        }): void;
        private ensureFeed(name);
        feed(name: TSignalEnum, signal?: any): void;
        consumeAll(name: string): number;
        hasFeed(name: string): boolean;
        consume(name: string): boolean | any;
        consumeWhenAvailableMergeToLast(name: TSignalEnum, callback: {
            (signal: any): void;
        }): void;
        consumeWhenAvailable(name: TSignalEnum, callback: {
            (signal: any): void;
        }): void;
        debug(option?: any): void;
        private debugStateHandler(option?, message?);
        private _assertingStateSequence;
        private _assertingStateCallback;
        private _assertingStateIndex;
        assertStateSequence(states: TStateEnum[], callback: (err: Error) => void): void;
        private _endStateAssertion(err?);
        private _updateStateAssertion(state);
    }
}
declare namespace Leaf {
    class ErrorDoc<TErrors> {
        private errorNames;
        private errors;
        static create<TErrors>(): ErrorDoc<TErrors>;
        define(name: string, base?: string | Error | Function, defaultProperty?: any): this;
        generate(): TErrors;
    }
    function createError(name: string, base?: Error | Function, defaultProperty?: any): (message: string, detail: any) => void;
    type Partial<T> = {
        [P in keyof T]?: T[P];
    };
    interface CustomErrorConstructor<TDetail> {
        new (message?: string, detail?: Partial<TDetail>): TDetail & Error;
    }
    const Errors: ErrorsOf<{
        Timeout: {};
        Abort: {};
        IOError: {};
        NetworkError: {};
    }>;
    type ErrorsOf<T> = {
        [P in keyof T]?: CustomErrorConstructor<T[P]>;
    };
}
declare namespace Leaf {
    interface APICallback<TResult> {
        (error: Error, result: TResult): void;
    }
    interface APIFunction<TOption, TResult> {
        (option: TOption, callback: APICallback<TResult>): void;
        API?: APIDeclare<TOption, TResult>;
    }
    interface APIOption {
        method: string | "GET" | "POST" | "PUT" | "DELETE";
        path: string;
        timeout?: number;
        headers?: any;
        data?: any;
        withCredentials?: boolean;
        bodyType?: "json" | "query";
    }
    class APIFactory {
        option: {
            root?: string;
            prefix?: string;
            suffix?: string;
            defaultTimeout?: number;
            withCredentials?: boolean;
            bodyType?: "json" | "query";
            errorMapper?: (err: Error) => Error;
        };
        constructor(option: {
            root?: string;
            prefix?: string;
            suffix?: string;
            defaultTimeout?: number;
            withCredentials?: boolean;
            bodyType?: "json" | "query";
            errorMapper?: (err: Error) => Error;
        });
        createAPI<TOption, TResult>(option: APIOption): APIDeclare<TOption, TResult>;
        createAPIFunction<TOption, TResult>(option: APIOption): APIFunction<TOption, TResult>;
        errorMapper: (err: Error) => Error;
        private solveResponse(err, response, callback);
        request<TResult>(option: {
            method?: string;
            url: string;
            query?: any;
            withCredentials?: boolean;
            headers?: any;
            timeout?: number;
            bodyType?: "json" | "query";
        }, callback: {
            (err, result: TResult): void;
        }): XMLHttpRequest;
        buildQueryString(query: any): string;
    }
    class APIDeclare<TOption, TResult> {
        private factory;
        private option;
        constructor(factory: APIFactory, option: APIOption);
        getFunction(): APIFunction<TOption, TResult>;
        invoke(data: TOption, callback: APICallback<TResult>): void;
    }
}
declare namespace Leaf {
    class History {
        handlePopState(): void;
        constructor();
        private stack;
        push(id: string, callback: Function): void;
        remove(id: string): void;
        activate(): void;
        deactivate(): void;
    }
}
declare namespace Leaf {
    class Model<TAttribute, TField extends string> {
        readonly _name: string;
        protected _fields: TField[];
        events: EventEmitter<string>;
        readonly fields: TField[];
        protected _data: TAttribute;
        readonly data: TAttribute;
        [index: string]: any;
        constructor(_name: string, _fields?: TField[]);
        private define(name, defaultValue?);
        hasKey(key: string): boolean;
        sets(obj: any): boolean;
        set(key: TField, value: any, silent?: boolean): boolean;
        get(key: TField): any;
        toJSON(): any;
    }
}
declare namespace Leaf {
    class Namespace {
        private Widgets;
        include(W: any, name?: string): void;
        getWidgetByName(name: string): WidgetConstructor;
        createWidgetByName(name: string, props?: any): WidgetAny;
        isTagWidgetName(name: string, who: WidgetAny): boolean;
        clear(): void;
        has(name: string): boolean;
    }
}
declare namespace Leaf {
    class ViewModel<TVMs, TVMField extends string> extends Model<TVMs, TVMField> {
        readonly _name: string;
        protected _fields: TVMField[];
        private depChain;
        constructor(_name: string, _fields?: TVMField[]);
        set(key: TVMField, value: any, silent?: boolean): boolean;
    }
    class DependencyChain {
        events: EventEmitter<"declare" | "revoke">;
        extractFunctionDependency(fn: Function): string[];
        maxDepth: number;
        updateFunctionDependency(name: string, fn: Function): void;
        validateDependency(target: string, src: string[], depth?: number): boolean;
        dependencyMap: {
            [index: string]: string[];
        };
    }
}
declare namespace Leaf {
    interface WidgetElement extends HTMLElement {
        widget: WidgetAny;
        propertyConfigs: WidgetDynamicPropertyConfig[];
    }
    interface WidgetDynamicPropertyConfig {
        master: WidgetAny;
        rules: DynamicProperties;
    }
    abstract class WidgetCoreDesign {
        protected widget: WidgetAny;
        constructor(widget: WidgetAny);
        subWidgetPlaceholder: {
            [index: string]: {
                holder: HTMLElement;
                dynamics: DynamicProperties;
                slots: Slot[];
            };
        };
        slotsPlaceholder: {
            [index: string]: {
                el: HTMLElement;
                name: string;
                dynamics: DynamicProperties;
                index: number;
            };
        };
        slotIndexOffset: number;
        abstract attachElement(el: WidgetElement, dynamics: DynamicProperties): any;
        abstract detachElement(el: WidgetElement): any;
        abstract attachText(text: Text, config: DynamicStringConfig): any;
        abstract detachText(text: Text): any;
        abstract extractDynamicPropertyConfig(el: WidgetElement): DynamicProperties;
        abstract extractDynamicStringConfig(content: string): DynamicStringConfig;
        abstract attachDynamicProperty(el: WidgetElement, dynamics: DynamicProperties): any;
        abstract detachDynamicProperty(el: WidgetElement): any;
        abstract getExistDynamicProperty(el: WidgetElement): DynamicProperties;
        abstract syncDynamicProperties(el: WidgetElement): any;
        abstract syncDynamicProperty(el: WidgetElement, name: string): any;
        abstract syncDynamicText(text: Text, rule: DynamicStringConfig): any;
        abstract attachDynamicText(text: Text, rule: DynamicStringConfig): any;
        abstract detachDynamicText(text: Text): any;
        abstract bindUI(node: WidgetElement, id: string): any;
        abstract unbindUI(id: string): any;
        abstract checkAndBindUI(el: WidgetElement): any;
        abstract checkAndUnbindUI(el: WidgetElement): any;
        protected abstract explain(config: DynamicValueConfig): any;
        abstract defineSlot(name: string, el: Element, dynamics: DynamicProperties): any;
        abstract fillSlots(slots: Slot[]): any;
        abstract defineSubWidget(name: string, el: WidgetElement, dynamics: DynamicProperties, slots: Slot[]): any;
        abstract setSubWidget(name: string, widget: any): any;
        abstract mergeProps(from: HTMLElement, to: HTMLElement, props: string[]): any;
        abstract defineList(name: string, el: HTMLElement): any;
        abstract extractTemplates(node: HTMLElement): {
            [index: string]: string;
        };
        abstract transferProperties(to: WidgetElement, dynamics: DynamicProperties): any;
    }
    abstract class WidgetInitializerDesign {
        protected widget: WidgetAny;
        constructor(widget: WidgetAny);
        abstract initTemplate(template?: WidgetTemplate): any;
        abstract traverseAndInitialize(node: WidgetElement | HTMLElement | Text): any;
        abstract createElement(tagName: string, properties: ElementConfigProperties, children: WidgetElement[]): WidgetElement;
        abstract createText(rule: DynamicStringConfig): any;
    }
    class WidgetCore extends WidgetCoreDesign {
        attachElement(el: WidgetElement, dynamics: DynamicProperties): WidgetElement;
        detachElement(el: WidgetElement): void;
        attachText(text: Text, config: DynamicStringConfig): void;
        detachText(text: Text): void;
        extractDynamicPropertyConfig(el: WidgetElement): DynamicProperties;
        getExistDynamicProperty(el: WidgetElement): DynamicProperties;
        syncDynamicProperties(el: WidgetElement): void;
        syncDynamicProperty(el: WidgetElement, propertyName: string): void;
        syncDynamicText(text: Text, rule: DynamicStringConfig): void;
        explain(config: DynamicValueConfig): any;
        checkAndUnbindUI(el: WidgetElement): void;
        checkAndBindUI(el: WidgetElement): void;
        bindUI(node: WidgetElement, id: string): void;
        unbindUI(id: string): void;
        defineSubWidget(name: string, el: WidgetElement, dynamics: DynamicProperties, slots: Slot[]): void;
        setSubWidget(name: string, widget: WidgetAny): void;
        attachDynamicProperty(el: WidgetElement, dynamics?: DynamicProperties): void;
        detachDynamicProperty(el: WidgetElement): void;
        attachDynamicText(text: Text, rule: DynamicStringConfig): void;
        detachDynamicText(text: Text): void;
        extractTemplates(node: HTMLElement): {};
        defineSlot(name: string, el: Element, dynamics: DynamicProperties): void;
        fillSlots(slots: Slot[]): void;
        extractDynamicStringConfig(content: string): DynamicStringConfig;
        mergeProps(from: HTMLElement, to: HTMLElement, props: string[]): void;
        transferProperties(to: WidgetElement, dynamics: DynamicProperties): void;
        defineList(name: string, el: HTMLElement): void;
        protected getPropsFromElement(el: HTMLElement): {};
        protected getChildrenAsSlot(el: HTMLElement): Slot[];
        protected getSlotHolder(name: string, index: number): {
            el: HTMLElement;
            name: string;
            dynamics: DynamicProperties;
            index: number;
        };
    }
    class WidgetInitializer extends WidgetInitializerDesign {
        initTemplate(template?: WidgetTemplate): any;
        traverseAndInitialize(node: WidgetElement | Text): void;
        createElement(tagName: string, properties: ElementConfigProperties, children: WidgetElement[]): WidgetElement;
        createText(rule: DynamicStringConfig): Text;
    }
    class WidgetDOMEventDelegator {
        readonly widget: any;
        constructor(widget: any);
        private lazyHandlers;
        private prepareUIDelegates(uiName);
        private prepareUIDelegate(uiName, eventName);
        private unbindLazyHandler(uiName, eventName);
        private bindLazyHandler(uiName, eventName);
        private provideLazyHandler(uiName, eventName, v);
        clearUIDelegateOwner(id: string): void;
        applyUIDelegateOwner(id: string): void;
        private delegateTo(name, event);
    }
}
declare namespace Leaf {
    class Widget<TUIs extends {
        [index: string]: HTMLElement;
    }, TVMs, TVMField extends string> {
        template: WidgetTemplate;
        _VMFields: TVMField[];
        static namespace: Namespace;
        static events: EventEmitter<"create">;
        namespace: Namespace;
        static setTemplate(template: WidgetTemplate): void;
        ListItemData: any;
        VM: TVMs;
        ViewModel: ViewModel<TVMs, TVMField>;
        parent: WidgetAny;
        events: EventEmitter<string>;
        UI: TUIs;
        node: WidgetElement;
        templates: {
            [index: string]: string;
        };
        providingEvents: DOMEventInfo[];
        interestingUnbubblingEvents: DOMEventInfo[];
        interestingBubblingEvents: DOMEventInfo[];
        readonly name: string;
        readonly core: WidgetCoreDesign;
        readonly delegates: WidgetDOMEventDelegator;
        readonly initializer: WidgetInitializerDesign;
        toString(): string;
        before(who: WidgetAny | HTMLElement): boolean;
        after(who: WidgetAny | HTMLElement): boolean;
        prependTo(who: WidgetAny | HTMLElement): boolean;
        appendTo(who: WidgetAny | HTMLElement): boolean;
        constructor(template?: WidgetTemplate, name?: string, _VMFields?: TVMField[]);
        static makeList<TListItem extends ListItem>(el: HTMLElement): List<TListItem>;
        protected emitDOMEvent(name: string, bubble: boolean, props?: any): void;
        protected emitWidgetEvent(name: string, value?: any): void;
        protected include(W: any): void;
        protected expose(name: string, remoteName?: string): void;
        protected makeList<T extends ListItem>(who: string | HTMLElement): List<T>;
    }
    abstract class GeneratedWidget<TUIs extends {
        [index: string]: HTMLElement;
    }, TVMs, TVMField extends string> extends Widget<TUIs, TVMs, TVMField> {
        private generator;
        _VMFields: TVMField[];
        constructor(generator: Function, name: string, _VMFields?: TVMField[]);
        GeneratedConstructor: WidgetConstructor;
        BindedWidgets: {
            path: string;
            name: string;
        }[];
        BindedLists: {
            name: string;
            type: "inline" | "reference" | "void" | string;
            reference: string;
        }[];
        TestDatas: {
            name: string;
            content: string;
            json: any;
        }[];
        InitialData: any;
        initGeneratedTemplate(node: WidgetElement): void;
        protected _e(tagName: string, properties: ElementConfigProperties, children: WidgetElement[]): WidgetElement;
        protected _t(rule: DynamicStringConfig): Text;
        renderRecursive(data?: any, R?: any): void;
        private resolveWidgetByPath(R, path);
    }
    interface StandaloneWidgetConstructor {
        new (): WidgetAny;
    }
    interface WidgetConstructor {
        new (el: HTMLElement): WidgetAny;
    }
    type WidgetAny = Widget<any, any, any>;
}
declare namespace Leaf {
    class List<TListItem extends ListItem> extends Widget<any, any, any> {
        [index: number]: TListItem;
        ListItemConstructor: WidgetConstructor;
        constructor(el: HTMLElement);
        fill(datas: any[], Cons: WidgetConstructor): void;
        events: Leaf.EventEmitter<"child/add" | "child/change" | "child/remove">;
        private _length;
        length: number;
        forEach: (callbackFn: (item: TListItem, index?: number, array?: TListItem[]) => void) => void;
        some: (callbackFn: (item: TListItem, index?: number, array?: TListItem[]) => boolean) => boolean;
        every: (callbackFn: (item: TListItem, index?: number, array?: TListItem[]) => boolean) => boolean;
        map: (callbackFn: (item: TListItem, index?: number, array?: TListItem[]) => any) => any[];
        filter: (callbackFn: (item: TListItem, index?: number, array?: TListItem[]) => boolean) => TListItem[];
        slice: (start?: number, end?: number) => TListItem[];
        indexOf(item: TListItem): number;
        private check(item);
        push(...items: TListItem[]): void;
        pop(): TListItem;
        unshift(item: TListItem): number;
        shift(): TListItem;
        splice(index: number, count?: number, ...toAdd: TListItem[]): TListItem[];
        removeItem(item: TListItem): TListItem;
        private attach(item);
        private detach(item);
        toArray(): TListItem[];
    }
    interface ListItem extends Widget<any, any, any> {
    }
}
declare namespace Leaf {
    type RPCId = number;
    const RPCErrors: ErrorsOf<{
        APINotExists: any;
        Timeout: any;
        Conflict: any;
        BrokenConnection: any;
    }>;
    interface RPCCallback<TResult> {
        (error: Error, result: TResult): void;
    }
    interface RPCInvoke<TOption, TResult> {
        (option?: TOption, callback?: RPCCallback<TResult>): void;
        RPC?: RPCDeclare<TOption, TResult>;
    }
    interface RPCOption {
        name: string;
        timeout?: number;
    }
    interface RPCMethodHandler {
        (data: any, callback: {
            (err?: Error, data?: any): void;
        }): void;
    }
    class RPCComposer {
        option: {
            defaultTimeout?: number;
        };
        declares: any;
        requestOffset: number;
        methods: {
            [index: string]: RPCMethodHandler;
        };
        remoteEvents: EventEmitter<string>;
        private connection;
        private responseHandlers;
        customNormalize: {
            (data: any): string;
        };
        customDenormalize: {
            (data: string): any;
        };
        private allocateId();
        constructor(option?: {
            defaultTimeout?: number;
        });
        setConnection(con: RPCConnection): void;
        unsetConnection(): void;
        registerRPCMethod(name: string, handler: RPCMethodHandler): void;
        createRPCDeclare<TOption, TResult>(option: RPCOption): RPCDeclare<TOption, TResult>;
        createRPCInvokeInterface<TOption, TResult>(option: RPCOption): RPCInvoke<TOption, TResult>;
        emitRemoteEvent(name: string, data?: any): void;
        invoke(name: string, data: any, callback?: Function, option?: {
            timeout?: number;
        }): void;
        private send(data);
        private handleMessage(rawString);
        private handleInvoke(req);
        private handleResponse(res);
        private handleEvent(event);
        private transformObject(data, handler);
        private normalize(data);
        private denormalize(data);
        private finishHandler(id, err?, value?);
    }
    class RPCDeclare<TOption, TResult> {
        private center;
        private option;
        constructor(center: RPCComposer, option: RPCOption);
        getFunction(): RPCInvoke<TOption, TResult>;
        invoke(data?: TOption, callback?: RPCCallback<TResult>): void;
    }
    type RPCBaseConnectionMessage = string;
    interface RPCConnection {
        events: EventEmitter<"message" | "close">;
        send: {
            (data: string): void;
        };
    }
    abstract class RPCConnectionBase implements RPCConnection {
        events: EventEmitter<string>;
        abstract send(data: string): void;
    }
    enum RPCProtocolBlobType {
        INVOKE = 1,
        RESPONSE = 2,
        EVENT = 3,
    }
    interface RPCResponseHandler {
        id: RPCId;
        callback: Function;
        timer: any;
        finished: boolean;
    }
    interface RPCProtocolBlob {
        type: RPCProtocolBlobType;
    }
    interface RPCProtocolResponseBlob extends RPCProtocolBlob {
        id: RPCId;
        data?: any;
        error?: any;
        type: RPCProtocolBlobType;
    }
    interface RPCProtocolInvokeBlob extends RPCProtocolBlob {
        id: RPCId;
        method: string;
        data: any;
        type: RPCProtocolBlobType;
    }
    interface RPCProtocolEventBlob extends RPCProtocolBlob {
        name: string;
        data: any;
        type: RPCProtocolBlobType;
    }
    class RPCBrowserWebSocketConnection extends RPCConnectionBase implements RPCConnection {
        connection: WebSocket;
        constructor(connection: WebSocket);
        send(content: string): void;
    }
}
declare namespace Leaf {
    namespace CoreLogic {
        function createDynamicValueConfigs(templateString: string): DynamicValueConfig[];
        const MergablePropertyNames: string[];
        function isPropertyMergable(name: string): boolean;
        function mergeProperty(name: string, values: string[]): string;
        const BubbleEvents: {
            name: string;
            bubble: boolean;
        }[];
        const UnbubbleEvents: {
            name: string;
            bubble: boolean;
            target: string[];
        }[];
        const AllEvents: {
            name: string;
            bubble: boolean;
        }[];
        function explainDynamicString(model: Model<any, any>, config: DynamicStringConfig): string;
        function explainDynamicValue(model: Model<any, any>, config: DynamicValueConfig): any;
    }
}
declare namespace Leaf {
    namespace Key {
        let cmd: number;
        let a: number;
        let b: number;
        let c: number;
        let d: number;
        let e: number;
        let f: number;
        let g: number;
        let h: number;
        let i: number;
        let j: number;
        let k: number;
        let l: number;
        let m: number;
        let n: number;
        let o: number;
        let p: number;
        let q: number;
        let r: number;
        let s: number;
        let t: number;
        let u: number;
        let v: number;
        let w: number;
        let x: number;
        let y: number;
        let z: number;
        let space: number;
        let shift: number;
        let ctrl: number;
        let alt: number;
        let left: number;
        let up: number;
        let right: number;
        let down: number;
        let enter: number;
        let backspace: number;
        let escape: number;
        let del: number;
        let esc: number;
        let pageup: number;
        let pagedown: number;
        let tab: number;
        let home: number;
        let end: number;
        let quote: number;
        let openBracket: number;
        let closeBracket: number;
        let backSlash: number;
        let slash: number;
        let equal: number;
        let comma: number;
        let period: number;
        let dash: number;
        let semiColon: number;
        let graveAccent: number;
    }
    namespace Mouse {
        let left: number;
        let middle: number;
        let right: number;
    }
}
declare namespace Leaf {
}
export = Leaf
