/// <reference path="../src/type.d.ts" />
declare namespace Leaf {
    interface DynamicValueConfig {
        type: "raw" | "value";
        content: string;
        value?: string;
        reverse?: boolean;
    }
    interface DynamicStringConfig {
        templates: DynamicValueConfig[];
    }
    interface DynamicPropertyConfig extends DynamicStringConfig {
        name: string;
    }
    type DOMEventInfo = {
        name: string;
        bubble: boolean;
        target?: string[];
    };
    type ElementConfigProperties = {
        [index: string]: DynamicPropertyConfig | string;
    };
    type DynamicProperties = {
        [index: string]: DynamicPropertyConfig;
    };
    type WidgetEventHandler = {
        (e: Event): void;
    };
    type WidgetTemplate = string | HTMLElement | {
        (): string | HTMLElement;
    };
    interface WidgetEnhancedEvent extends Event {
        capture?: {
            (): void;
        };
        bubblingTarget: HTMLElement;
    }
    type Slot = {
        name: string;
        el: Element | Text;
    };
    type Callback<T = null, E extends Error = Error> = (error?: E, option?: T) => void;
}
declare namespace Leaf {
    class Logger {
        static debug(...args: any[]): void;
        static error(...args: any[]): void;
        static log(...args: any[]): void;
        static line(str: string): void;
        static lineEnd(): void;
        static trace(): void;
    }
}
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 withProps(who: any): WithProperty<unknown>;
    }
    class WithProperty<T> {
        who: any;
        constructor(who: any);
        define<T>(name: string, def: PropertyDefination<T>): this;
    }
}
declare namespace Leaf {
    class Serializer {
        typeKey: string;
        dataKey: string;
        typeMap: {
            [type: string]: Serializer.ConvertConfig;
        };
        private tokenize;
        private detokenize;
        serialize(data: any): string;
        deserialize(data: any): any;
        register(type: string, config: Serializer.ConvertConfig): void;
        static defaultSerializer: Serializer;
        static getDefault(): Serializer;
    }
    namespace Serializer {
        type Constructor<T = {}> = new (...args: any[]) => T;
        interface ConvertConfig<T = any, V = any> {
            Cons: Constructor<T>;
            fromType: (T: any) => V;
            toType: (V: any) => T;
        }
    }
}
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 dictDiff<T>(d1: {
            [index: string]: T;
        }, d2: {
            [index: string]: T;
        }, identical?: (a: T, b: T) => boolean): {
            left: string[];
            right: string[];
            interact: string[];
            intersect?: string[];
        };
        static arrayDiffTyped<TLeft = any, TRight = TLeft>(arr1: TLeft[], arr2: TRight[], identical?: (a: TLeft, b: TRight) => boolean): {
            left: TLeft[];
            right: TRight[];
            leftShare: TLeft[];
            rightShare: TRight[];
        };
        static arrayDiff<T>(arr1?: T[], arr2?: T[], identical?: (a: T, b: T) => boolean): {
            left: T[];
            right: T[];
            interact: T[];
            intersect: T[];
        };
        static buildOption<T>(defaultOption: T, option?: Partial<T>): T;
        static getBrowserInfo(): BrowserInfo;
        static isMobile(): boolean;
        static browser: BrowserInfo;
        static isEmptyValue(v: any): boolean;
        static getObjectValue(obj: any, path: string): any;
        static reconstructObjectMap(map: any): {};
    }
    interface BrowserInfo {
        name: string;
        version: string;
        mobile: boolean;
    }
    interface SharedCallbackFunction {
        (...args: any[]): void;
        push?: {
            (fn: Function): void;
        };
        clear?: {
            (): void;
        };
        callbacks?: Function[];
        count?: number;
    }
    const SharedCallbacks: {
        create(): SharedCallbackFunction;
    };
}
declare namespace Leaf {
    type Match = {
        path: string;
        type: "lte" | "gte" | "lt" | "gt" | "eq" | "reg" | "wildcard" | "in";
        reference?: string;
        value?: any;
        optional?: boolean;
    } & Tagged<"match">;
    namespace Condition {
        function empty(): Criteria;
        function never(): CriteriaTemplate;
        function realize<T extends object>(template: CriteriaTemplate, data: T | T[]): Criteria;
        function and<T extends Criteria | CriteriaTemplate>(...criterias: T[]): T;
        function criteriaToTemplateByPath(cri: Criteria): CriteriaTemplate;
        function criteriaToValue(cri: Criteria): any;
        function or(criterias: Criteria[]): Criteria;
        function build(cri: CriteriaTemplate, obj?: any): Criteria;
        function test(condition: Criteria | Matches | Match, data: any): boolean;
        function testCriteria(cri: Criteria, data: any): boolean;
        function testMatches(matches: Matches, data: any): boolean;
        function testMatch(match: Match, data: any): boolean;
        function subInplace(criteria: Criteria | CriteriaTemplate, path: string): void;
    }
    class CriteriaBuilder {
        tb: CriteriaTemplateBuilder;
        sub(path: string): void;
        path(path: string): this;
        lt(value: number): this;
        gt(value: number): this;
        lte(value: number): this;
        gte(value: number): this;
        eq(value: number | string | boolean): this;
        in(value: string[] | number[]): this;
        reg(value: RegExp): this;
        build(): Criteria;
    }
    class CriteriaTemplateBuilder {
        currentPath: string;
        currentConditions: Matches;
        criteria: CriteriaTemplate;
        currentOptional: boolean;
        optional(): this;
        getTemplate(): CriteriaTemplate;
        private ensureCurrentConditions;
        private createEmptyConditions;
        private isEmptyMatches;
        path(path: string): this;
        gt(reference: string, value?: number): this;
        lt(reference: string, value?: number): this;
        lte(reference: string, value?: number): this;
        gte(reference: string, value?: number): this;
        eq(reference: string, value?: number | string | boolean): this;
        in(reference: any, value?: string[] | number[]): this;
        or(): void;
        reg(reference: string, value?: RegExp): this;
        wildcard(): void;
        isSealed: boolean;
        seal(): this;
        private numericType;
        build(obj: any): Criteria;
    }
}
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 {
    type EventEmitterHandler<T> = (data: T, ...args: any[]) => void;
    interface EventHandlerInfo {
        owner?: any;
        once?: boolean;
        handler: Function;
    }
    interface EventHandlers {
        [index: string]: EventHandlerInfo[];
    }
    class EventEmitter<E = {
        [key: string]: any;
    }> {
        private events;
        readonly DECLARE: E;
        constructor();
        addEventListener<K extends keyof E>(event: K, handler: (data: E[K], ...args: any[]) => void): this;
        addListener: <K extends keyof E>(event: K, handler: (data: E[K], ...args: any[]) => void) => this;
        off: <K extends keyof E>(event?: keyof E, handler?: (data: E[K], ...args: any[]) => void) => this;
        removeAllListeners(): void;
        on<K extends keyof E>(event: keyof E, handler: (data: E[K], ...args: any[]) => void): this;
        once<K extends keyof E>(event: keyof E, handler: (data: E[K], ...args: any[]) => void): this;
        listenByOnce<K extends keyof E>(who: any, event: K, handler: (data: E[K], ...args: any[]) => void): this;
        listenBy<K extends keyof E>(who: any, event: K | K[], handler: (data: E[K], ...args: any[]) => void): this;
        stopListenBy<K extends keyof E>(who: any, event?: keyof E, handler?: (data: E[K], ...args: any[]) => void): this;
        removeEventListener<K extends keyof E>(event?: keyof E, handler?: (data: E[K], ...args: any[]) => void): this;
        emit<K extends keyof E>(event: K, ...values: E[K][]): this;
        private getOrCreateEventHandlers;
    }
}
declare namespace Leaf {
    type TStateDefaultEnum = "void" | "panic" | "recursivePanic";
    class States<TStateEnum extends string = string, TSignalEnum = {
        [key: string]: any;
    }> {
        events: EventEmitter<{
            [key: string]: any;
            reset?: void;
            state?: TStateEnum | "void" | "panic" | "recursivePanic";
        }>;
        state: TStateEnum | TStateDefaultEnum;
        previousState: TStateEnum | TStateDefaultEnum;
        private sole;
        private soleEmitted;
        private lastException;
        private rescues;
        protected data: any;
        private feeds;
        private isDebugging;
        private clearHandler;
        name: string;
        panicErrorRecursive: Error;
        panicError: Error;
        panicState: TStateEnum | TStateDefaultEnum;
        constructor();
        reset(): void;
        errorOrGoto(err: any, state: string, ...args: any[]): void;
        setState(state: TStateEnum | TStateDefaultEnum, ...args: any[]): void;
        private _stateFinish;
        protected clearConsumers(): void;
        private _setState;
        error(err: Error): void;
        protected atPanic(): void;
        recover(recoverState?: TStateEnum | TStateDefaultEnum): {
            error: Error;
            state: TStateEnum | "void" | "panic" | "recursivePanic";
        };
        respawn(): void;
        clear(handler?: {
            (): void;
        }): void;
        private ensureFeed;
        feed(name: keyof TSignalEnum, signal?: any): void;
        consumeAll(name: keyof TSignalEnum): number;
        hasFeed(name: keyof TSignalEnum): boolean;
        consume(name: keyof TSignalEnum): boolean | any;
        consumeWhenAvailableMergeToLast<K extends keyof TSignalEnum>(name: K, callback: {
            (signal: TSignalEnum[K]): void;
        }): void;
        isConsuming(name: keyof TSignalEnum): boolean;
        consumeWhenAvailable(name: keyof TSignalEnum, callback: {
            (signal: any): void;
        }): void;
        debug(option?: any): void;
        private debugStateHandler;
        setLogger(logger: (...infos: any[]) => void): void;
        private _logger;
        private _assertingStateSequence;
        private _assertingStateCallback;
        private _assertingStateIndex;
        assertStateSequence(states: TStateEnum[], callback: (err: Error) => void): void;
        private _endStateAssertion;
        private _updateStateAssertion;
        protected atRecursivePanic(): void;
        private setImmediate;
    }
}
declare namespace Leaf {
    class ErrorDoc<TErrors> {
        private errorNames;
        private errors;
        static create<TErrors>(): ErrorDoc<TErrors>;
        static build<TErrors>(info: TErrors): {
            [K in keyof TErrors]: CustomErrorConstructor<TErrors[K]>;
        };
        define(name: string, base?: string | Error | Constructor<Error>, defaultProperty?: any): this;
        generate(): TErrors;
    }
    type Constructor<T> = {
        new (...params: any[]): T;
    };
    function createError(name: string, Base?: Constructor<Error>, defaultProperty?: any): {
        new (message: string, detail: any): {
            message: string;
            name: string;
            detail: any;
            via: Error;
            toJSON: () => any;
            stack?: string;
        };
    };
    type Partial<T> = {
        [P in keyof T]?: T[P];
    };
    interface CustomErrorConstructor<TDetail> {
        new (message?: string, detail?: Partial<TDetail> & {
            via?: Error;
        }): {
            detail: TDetail;
        } & Error & {
            via: Error;
        };
    }
    const Errors: ErrorsOf<{
        Timeout: {};
        Abort: {};
        IOError: {};
        NetworkError: {
            raw?: string;
        };
    }>;
    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>;
        mock: (option: TOption, error?: Error, result?: TResult) => APIFunction<TOption, TResult>;
        with(data: Partial<TOption>): APIFunction<TOption, TResult>;
        transform<TModifiedResult>(result: (option: TResult) => TModifiedResult): ({
            (option: TOption, callback: APICallback<TModifiedResult>): void;
        });
    }
    interface APIOption {
        method: string | "GET" | "POST" | "PUT" | "DELETE";
        path: string;
        timeout?: number;
        headers?: any;
        data?: any;
        withCredentials?: boolean;
        bodyType?: "json" | "query";
        mock?: boolean;
    }
    class APIFactory {
        option: {
            root?: string;
            prefix?: string;
            suffix?: string;
            defaultTimeout?: number;
            withCredentials?: boolean;
            headers?: any;
            bodyType?: "json" | "query";
            mock?: boolean;
            errorMapper?: (err: Error) => Error;
            serializer?: {
                serialize: (data: any) => string;
                deserialize: (data: string) => any;
            };
        };
        lastResponse: string;
        responseHandler: {
            (response: string, callback: (error: Error, data: any) => void): void;
        };
        private _handleResponse;
        constructor(option: {
            root?: string;
            prefix?: string;
            suffix?: string;
            defaultTimeout?: number;
            withCredentials?: boolean;
            headers?: any;
            bodyType?: "json" | "query";
            mock?: boolean;
            errorMapper?: (err: Error) => Error;
            serializer?: {
                serialize: (data: any) => string;
                deserialize: (data: string) => any;
            };
        });
        createAPI<TOption, TResult>(option: APIOption): APIDeclare<TOption, TResult>;
        createAPIFunction<TOption, TResult>(option: APIOption): APIFunction<TOption, TResult>;
        errorMapper: (err: Error) => Error;
        private solveResponse;
        request<TResult>(option: {
            method?: string;
            url: string;
            query?: any;
            withCredentials?: boolean;
            headers?: any;
            timeout?: number;
            bodyType?: "json" | "query";
        }, callback: {
            (err: any, result: TResult): void;
        }): XMLHttpRequest;
        buildQueryString(query: any): string;
    }
    class APIDeclare<TOption, TResult> {
        private factory;
        private option;
        private mocks;
        constructor(factory: APIFactory, option: APIOption);
        mock(option: TOption, error?: Error, result?: TResult): this;
        private _mock;
        private decorateAPIOption;
        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 DataSource<TAttribute> {
        readonly _name: string;
        protected _fields: (keyof TAttribute)[];
        events: EventEmitter<{
            [key: string]: any;
            change: Partial<TAttribute>;
        }>;
        readonly fields: (keyof TAttribute)[];
        id: string;
        protected _data: TAttribute;
        readonly data: TAttribute;
        [index: string]: any;
        constructor(_name: string, _fields?: (keyof TAttribute)[]);
        protected define(name: keyof TAttribute, defaultValue?: any): void;
        hasKey(key: string): boolean;
        sets(obj: any): boolean;
        set(key: keyof TAttribute, value: any, silent?: boolean): boolean;
        get(key: keyof TAttribute): any;
        toJSON<T>(): any;
    }
    class Model<T> extends DataSource<T> {
    }
    class DataTree<TAttribute = any> {
        readonly source: DataSource<TAttribute>;
        constructor(source: DataSource<TAttribute>);
        getNode(path?: string): DataNode<any>;
        valueCanBeObject(v: any): boolean;
        getValueByPath(path: string): any;
        setValueByPath(path: string, v: any): boolean;
    }
    class DataNode<T = any> {
        readonly tree: DataTree;
        readonly path: string;
        constructor(tree: DataTree, path?: string);
        getProxyOrValue(): any;
        set(v: T): boolean;
        get(): T;
        toString(): string;
    }
}
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> extends Model<TVMs> {
        readonly _name: string;
        protected _fields: (keyof TVMs)[];
        private depChain;
        constructor(_name: string, _fields?: (keyof TVMs)[]);
        tree: DataTree<TVMs>;
        set(key: keyof TVMs, value: any, silent?: boolean): boolean;
    }
    class DependencyChain {
        events: EventEmitter<{
            declare: {
                src: string;
                target: string;
            };
            revoke: {
                src: string;
                target: string;
            };
        }>;
        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: Leaf.DynamicStringConfig): any;
        abstract detachText(text: Text): any;
        abstract extractDynamicPropertyConfig(el: WidgetElement): DynamicProperties;
        abstract extractDynamicStringConfig(content: string): Leaf.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: Leaf.DynamicStringConfig): any;
        abstract attachDynamicText(text: Text, rule: Leaf.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: Leaf.DynamicStringConfig): any;
    }
    class WidgetCore extends WidgetCoreDesign {
        attachElement(el: WidgetElement, dynamics: DynamicProperties): WidgetElement;
        detachElement(el: WidgetElement): void;
        attachText(text: Text, config: Leaf.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: Leaf.DynamicStringConfig): void;
        explain(config: DynamicValueConfig): any;
        checkAndUnbindUI(el: WidgetElement): void;
        checkAndBindUI(el: WidgetElement, name?: string): 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: Leaf.DynamicStringConfig): void;
        detachDynamicText(text: Text): void;
        extractTemplates(node: HTMLElement): {};
        defineSlot(name: string, el: Element, dynamics: DynamicProperties): void;
        fillSlots(slots: Slot[]): void;
        extractDynamicStringConfig(content: string): Leaf.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: Leaf.DynamicStringConfig): Text;
    }
    class WidgetDOMEventDelegator {
        readonly widget: any;
        constructor(widget: any);
        private lazyHandlers;
        private prepareUIDelegates;
        private prepareUIDelegate;
        private unbindLazyHandler;
        private bindLazyHandler;
        private provideLazyHandler;
        clearUIDelegateOwner(id: string): void;
        applyUIDelegateOwner(id: string): void;
        private delegateTo;
    }
    class WidgetSlotBehavior<T extends {
        [name: string]: Leaf.Widget;
    } = any> {
        readonly widget: Leaf.Widget;
        constructor(widget: Leaf.Widget);
        fill(...widgets: Leaf.Widget[]): any;
        fill(widgets: T): any;
        private fillSequentially;
        private fillNamingly;
    }
}
declare namespace Leaf {
    class Widget<TUIs extends {
        [index: string]: HTMLElement;
    } = {
        [index: string]: HTMLElement;
    }, TVMs = {
        [key: string]: any;
    }, THandlers extends {
        [key: string]: Function;
    } = {}> {
        template?: WidgetTemplate;
        _VMFields: (keyof TVMs)[];
        isWidget: boolean;
        static namespace: Namespace;
        static events: EventEmitter<{
            create: Widget<{
                [index: string]: HTMLElement;
            }, {
                [key: string]: any;
            }, {}>;
        }>;
        namespace: Namespace;
        static setTemplate(template: WidgetTemplate): void;
        ListItemData: any;
        VM: TVMs;
        VMNest: TVMs;
        ViewModel: ViewModel<TVMs>;
        parent: WidgetAny;
        events: EventEmitter;
        UI: TUIs;
        node: WidgetElement;
        templates: {
            [index: string]: string;
        };
        providingEvents: DOMEventInfo[];
        interestingUnbubblingEvents: DOMEventInfo[];
        interestingBubblingEvents: DOMEventInfo[];
        readonly asSlot: Leaf.WidgetSlotBehavior;
        private _asSlot;
        readonly widgetName: 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?: (keyof TVMs)[]);
        static makeList<TListItem extends ListItem>(el: HTMLElement): any;
        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: (keyof TUIs) | HTMLElement): any;
        behave(handler: THandlers): void;
    }
    abstract class GeneratedWidget<TUIs extends {
        [index: string]: HTMLElement;
    } = {
        [index: string]: HTMLElement;
    }, TVMs = {
        [key: string]: any;
    }, THandlers extends {
        [key: string]: Function;
    } = {}> extends Widget<TUIs, TVMs> {
        private generator;
        _VMFields: (keyof TVMs)[];
        constructor(generator: Function, name: string, _VMFields?: (keyof TVMs)[]);
        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: Leaf.DynamicStringConfig): Text;
        renderRecursive(data?: any, R?: any): void;
        private resolveWidgetByPath;
    }
    interface StandaloneWidgetConstructor {
        new (): WidgetAny;
    }
    interface WidgetConstructor {
        new (el: HTMLElement): WidgetAny;
    }
    type WidgetAny = Widget;
}
declare namespace Leaf {
    class List<TListItem extends ListItem = ListItem> extends Widget {
        [index: number]: TListItem;
        ListItemConstructor: WidgetConstructor;
        constructor(el: HTMLElement);
        fill(datas: any[], Cons: WidgetConstructor): void;
        events: Leaf.EventEmitter<{
            "child/add": TListItem;
            "child/change": TListItem;
            "child/remove": TListItem;
        }>;
        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[];
        empty(): void;
        indexOf(item: TListItem): number;
        private check;
        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;
        private detach;
        toArray(): TListItem[];
    }
    interface ListItem<TUIs extends {
        [index: string]: HTMLElement;
    } = {
        [index: string]: HTMLElement;
    }, TVMs = {
        [key: string]: any;
    }> extends Widget<TUIs, TVMs> {
    }
}
declare namespace Leaf {
    type RPCId = number;
    const RPCErrors: ErrorsOf<{
        APINotExists: any;
        Timeout: any;
        Conflict: any;
        BrokenConnection: any;
        Abort: 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;
    }
    function RPCMethod(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
    interface RPCMethodHandler {
        (data: any, callback: {
            (err?: Error, data?: any): void;
        }): void;
    }
    class RPCComposer<E = {}> {
        option: {
            defaultTimeout?: number;
        };
        declares: any;
        requestOffset: number;
        methods: {
            [index: string]: RPCMethodHandler;
        };
        remoteEvents: EventEmitter<{
            "*": { [K in keyof E]: E[K]; };
        } & { [P in keyof E]: E[P]; }>;
        isOpen(): boolean;
        protected connection: RPCConnection;
        private responseHandlers;
        customNormalize: {
            (data: any): string;
        };
        customDenormalize: {
            (data: string): any;
        };
        private allocateId;
        install(obj?: any, decorator?: (fn: Function, name?: string) => Function): void;
        constructor(option?: {
            defaultTimeout?: number;
        });
        setConnection(con: RPCConnection): void;
        events: EventEmitter<{
            open: any;
            close: any;
            timeout: any;
            response: {
                method: string;
                id: number;
                error: Error;
                value: any;
            };
        }>;
        unsetConnection(): void;
        revokeRPCMethod(name: string): 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;
        protected serializer: Serializer;
        protected serialize(data: any): string;
        protected deserialize(content: string): any;
        private send;
        private handleMessage;
        private handleInvoke;
        private handleResponse;
        private handleEvent;
        private transformObject;
        private normalize;
        private denormalize;
        private finishHandlerById;
        private finishHandler;
    }
    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: string;
            close: null;
            open: null;
        }>;
        describe?(): string;
        isOpen(): boolean;
        send(data: string): any;
        close(): any;
    }
    abstract class RPCConnectionBase implements RPCConnection {
        events: EventEmitter<{
            message: string;
            close: null;
            open: null;
        }>;
        abstract send(data: string): void;
        abstract close(): any;
        abstract isOpen(): boolean;
    }
    enum RPCProtocolBlobType {
        INVOKE = 1,
        RESPONSE = 2,
        EVENT = 3
    }
    interface RPCResponseHandler {
        id: RPCId;
        callback: Function;
        timer: any;
        finished: boolean;
        method: string;
    }
    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;
        isOpen(): boolean;
        close(): void;
        describe(): string;
    }
}
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: DataTree<any>, config: Leaf.DynamicStringConfig): string;
        function explainDynamicValue(tree: DataTree<any>, config: DynamicValueConfig): any;
        function getPropertyRoot(str: string): string;
    }
}
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 {
    const ValidatorErrors: {
        Invalid: CustomErrorConstructor<{
            path: string;
            code: any;
        }>;
    };
    type Stringable = {
        toString(): string;
    };
    type ComplexData = any;
    class Validator<T extends ComplexData = any, PV extends Validator = any, R extends ComplexData = any> {
        currentRouteName: string;
        readonly parent: PV;
        static currentReason: Stringable;
        static currentCode: any;
        static create<T extends ComplexData>(name: string): Validator<T, any, any>;
        constructor(currentRouteName: string, parent?: PV);
        clone(parent?: PV): this;
        private checkers;
        private children;
        field<K extends keyof T>(key: K): Validator<T[K], this, R>;
        with<K extends keyof T>(key: K, handler?: (validator: Validator<T[K], this>) => void): this;
        use(validator: Validator): this;
        private elementValidator;
        each<TElement = T[0]>(): Validator<TElement>;
        check(data: any, root?: any, parent?: any): void;
        reason(reason: Stringable): this;
        code(code: any): this;
        private addChecker;
        private getRoute;
        string(): this;
        int(): this;
        number(): this;
        has(): this;
        lt(num: number): this;
        gt(num: number): this;
        lte(num: number): this;
        gte(num: number): this;
        reg(reg: RegExp): this;
        pass(fn: (data: T, root?: R) => void): this;
    }
}
declare namespace Leaf {
    class ServiceStateModel<TState = {
        [key: string]: any;
    }> extends DataSource<TState> {
        constructor(service: Service, fields?: (keyof TState)[]);
    }
    type AnyService = Service;
    abstract class Service<TSettings = {}> {
        isInitialized: boolean;
        readonly dependencies: string[];
        abstract name: string;
        initialize(...args: any[]): void;
        settings: TSettings;
        constructor(defaultSettings?: TSettings, settings?: TSettings);
        events: EventEmitter<{
            [key: string]: any;
        }>;
        services: {
            [name: string]: AnyService;
        };
        private apiNames;
        connect(delegator: {
            invoke: (uri: string, data: any, callback: Function) => void;
        }): void;
        private bindAPINames;
        private api;
        createAPI<TOption, TResult>(handler?: (option: TOption, callback: (err?: Error, result?: TResult) => void) => void): {
            (option?: TOption, callback?: (err: Error, result: TResult) => void): void;
        };
    }
    interface TaggedFunction {
        tag?: "api";
        api?: string;
    }
    type DependencyMatcher = string | RegExp;
    class DependencyManager {
        private context;
        add(name: string, deps: DependencyMatcher[]): void;
        onAddDymanicDependency: (name: string) => void;
        resolveDependency(name: string, chain?: string[]): string[];
        resolve(): string[];
    }
    class ServiceSetupProcedure extends Leaf.States<string, string> {
        private services;
        private setupSequence;
        constructor(services: {
            [key: string]: AnyService;
        }, setupSequence: string[]);
        protected data: {
            dones?: Function[];
            todo?: string[];
        };
        setup(callback: (err: Error) => void): void;
        atPrepare(): void;
        atSetup(): void;
        atFinish(): void;
        atPanic(): void;
        private logInitialized;
    }
    class ServiceContext {
        private settings;
        private BuiltInServiceInstances;
        constructor(settings?: any);
        services: {
            [index: string]: AnyService;
        };
        dependencyManager: DependencyManager;
        register<T extends AnyService>(s: T): T;
        private procedure;
        setup(callback: (err: Error) => void): void;
    }
}
declare namespace Leaf {
    namespace Background {
        class ChannelBackgroundEnd {
        }
        class BackgroundLayer {
            version: string;
            private context;
            constructor(version?: string);
        }
    }
}
declare namespace Leaf {
    namespace Foreground {
        class ChannelForegroundEnd {
        }
        class ChannelForegroundLayer {
            version: string;
            private context;
            private rpc;
            private invokeBackgroundServiceAPI;
            private connectBackgroundLayer;
            constructor(version?: string);
        }
    }
}
declare namespace Leaf {
    interface ApplicationLifeCircle {
        foregroundInitialize: () => void;
        backgroundInitialize: () => void;
    }
    abstract class Application implements ApplicationLifeCircle {
        initialize(): void;
        implements(lifecircle: Partial<ApplicationLifeCircle>): void;
        foregroundInitialize: () => void;
        backgroundInitialize: () => void;
        serviceContext: ServiceContext;
    }
}
declare namespace Leaf {
    class Referencer {
        events: EventEmitter<{
            ref: any;
            deref: any;
            init: any;
            release: any;
        }>;
        counter: number;
        ref(): void;
        deref(): void;
    }
    class OwnerReferencer {
        ttl(time?: number): OwnerReferenceCachier;
        events: EventEmitter<{
            ref: any;
            deref: any;
            init: any;
            release: any;
        }>;
        refs: {
            owner: any;
            counter: number;
        }[];
        release(): void;
        getCounter(): number;
        refBy(who: any): boolean;
        derefBy(who: any): boolean;
    }
    class MultipleReference<T = any> {
        constructor();
        refs: {
            target: T;
            owner: any;
            counter: number;
        }[];
        targetRefs: {
            target: T;
            counter: number;
        }[];
        private refTarget;
        private derefTarget;
        private derefAll;
        refBy(who: any, target: T): boolean;
        derefBy(who: any, target?: T): boolean | void;
        events: EventEmitter<{
            init: T;
            release: T;
            ref: T;
            deref: T;
        }>;
    }
    class OwnerReferenceCachier {
        readonly referencer: OwnerReferencer;
        readonly time: number;
        constructor(referencer: OwnerReferencer, time?: number);
        timer: any;
        debounceDeref(): void;
        stopDebounceDeref(): void;
    }
}
declare namespace Leaf {
    type LifeOwner = {
        events?: Leaf.EventEmitter;
        life: Life;
    };
    class Life {
        readonly owner: LifeOwner;
        constructor(owner: any);
        private fns;
        referencer: OwnerReferencer;
        connect(referencer: OwnerReferencer): this;
        dead(fn: any): this;
        depends: LifeOwner[];
        children: LifeOwner[];
        uses: LifeOwner[];
        containBy(owner: LifeOwner): this;
        contain(item: LifeOwner): this;
        purge(item: LifeOwner): this;
        use(obj: LifeOwner): this;
        unuse(obj: LifeOwner): this;
        need(obj: LifeOwner): this;
        kill(): void;
        isDestroyed: boolean;
        events: EventEmitter<{
            dead: any;
        }>;
        private keeper;
        keep(): this;
        unkeep(): this;
        ttl(time?: number): this;
    }
}
declare namespace Leaf {
    class ReadyBehavior {
        isReady: boolean;
        private readyCallbacks;
        counter: number;
        debug: boolean;
        yes(): void;
        error(err: Error): void;
        no(): void;
        events: EventEmitter<{
            ready: any;
            unready: any;
        }>;
        whenReady(cb: Function): void;
    }
    class FrameBehavior {
        interval: number;
        setInterval(interval: number): this;
        private framer;
        frame(fn: (callback: Callback<null>) => void): this;
        isStart: boolean;
        start(): this;
        stop(): this;
        private isFrameActive;
        timer: any;
        do(): void;
        timeMode: string;
        mode(mode: "include" | "beteen"): this;
    }
}
declare namespace Leaf {
    class Debouncer {
        readonly option: {
            time: number;
            maxTime: number;
        };
        constructor(option: {
            time: number;
            maxTime: number;
        });
        previousEmit: number;
        timer: any;
        debounce(fn: Function): void;
    }
    class GroupDebouncer {
        readonly option: {
            time: number;
            maxTime: number;
        };
        constructor(option: {
            time: number;
            maxTime: number;
        });
        debouncers: {
            [name: string]: Debouncer;
        };
        debounce(name: string, fn: Function): void;
    }
}
declare namespace Leaf {
}
declare module "leaf-ts" {
    export = Leaf
}
///<reference path="./type.d.ts" />