declare module 'src/interaction/TouchMouseEventEnum' {
	/**
	 * 鼠标点击与触摸事件枚举,内部DisplayObject使用
	 * @since 1.0.0
	 */
	export const enum TouchMouseEventEnum {
	    mousedown = "mousedown",
	    mousemove = "mousemove",
	    mouseup = "mouseup",
	    mouseover = "mouseover",
	    mouseout = "mouseout",
	    mouseupoutside = "mouseupoutside",
	    mouseRightDown = "rightdown",
	    mouseRightup = "rightup",
	    mouseRightupoutside = "rightupoutside",
	    touchstart = "touchstart",
	    touchcancel = "touchcancel",
	    touchend = "touchend",
	    touchendoutside = "touchendoutside",
	    touchmove = "touchmove",
	    tap = "tap"
	}

}
declare module 'src/event/InteractionEvent' {
	///   types="@vf.js/vf" />
	/**
	 * 事件的基础类
	 *
	 * 触摸或鼠标操作事件 可查看 -> TouchEventEnum.TouchEnum
	 *
	 * import InteractionEvent from "../interaction/InteractionEvent",
	 */
	export class InteractionEvent extends vf.InteractionEvent {
	    constructor();
	    local: vf.Point;
	    path?: number[];
	    signalling: boolean;
	}

}
declare module 'src/event/TouchMouseEvent' {
	/**
	 * 对外，封装的点击触摸事件
	 *
	 * import InteractionEvent,{Mouse} from "../interaction/InteractionEvent",
	 */
	export const TouchMouseEvent: {
	    /**
	     * 移出
	     *
	     * (e: InteractionEvent,thisObj:DisplayObject,over: boolean)=>{}
	     */
	    onHover: string;
	    /**
	     * 按下
	     *
	     * (e: InteractionEvent,thisObj:DisplayObject, isPressed: boolean)=>void
	     */
	    onPress: string;
	    /**
	     * 按下
	     */
	    onDown: string;
	    /**
	     * 弹起
	     */
	    onUp: string;
	    /**
	     * 点击
	     *
	     * (e: InteractionEvent,thisObj:DisplayObject)=>void
	     */
	    onClick: string;
	    /**
	     * PC 特有，右键点击
	     *
	     * (e: InteractionEvent,thisObj:DisplayObject)=>void
	     */
	    onRightDown: string;
	    /**
	     * 移动
	     *
	     * (e: InteractionEvent,thisObj:DisplayObject)=>void
	     */
	    onMove: string;
	    /**
	     * 鼠标移入
	     *
	     * (e: InteractionEvent,thisObj:DisplayObject)=>void
	     */
	    onMouseEnter: string;
	    /**
	     * 鼠标移出
	     *
	     * (e: InteractionEvent,thisObj:DisplayObject)=>void
	     */
	    onMouseLeave: string;
	};

}
declare module 'src/tween/Easing' {
	/**
	 * 完整的缓动曲线列表
	 *
	 * @example vf.gui.Easing.Linear.None;
	 *
	 */
	export const Easing: {
	    Linear: {
	        None(k: number): number;
	    };
	    Quadratic: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Cubic: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Quartic: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Quintic: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Sinusoidal: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Exponential: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Circular: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Elastic: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Back: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Bounce: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Stepped: {
	        steps: (steps: number) => (k: number) => number;
	    };
	};

}
declare module 'src/tween/private/constants' {
	/**
	 * 卡帧后的平滑处理帧率
	 */
	export const FRAME_MS: number;
	/**
	 * 平滑处理允许的触发时间
	 */
	export const TOO_LONG_FRAME_MS = 250;
	/**
	 * 链式补间动画的key前缀
	 */
	export const CHAINED_TWEENS = "_chainedTweens";
	export const STRING_PROP = "STRING_PROP";
	export const NUM_REGEX: RegExp;
	export function decomposeString(fromValue: string | any): any;
	export function decompose(prop: any, obj: any, from: any, to: any): any;
	export const RGB = "rgb(";
	export const RGBA = "rgba(";
	export function isRGBColor(v: any, i: number, r?: string): boolean;
	export function recompose(prop: any, obj: any, from: any, to: any, t: any, originalT: any, stringBuffer?: any): any;
	export const SET_NESTED: (nested: any) => any;

}
declare module 'src/tween/private/Interpolation' {
	/**
	 * 差值计算列表
	 * @example
	 *
	 * let bezier = vf.gui.tween.Interpolation.Bezier
	 * new vf.gui.tween.Tween({x:0}).to({x:[0, 4, 8, 12, 15, 20, 30, 40, 20, 40, 10, 50]}, 1000).interpolation(bezier).start()
	 * @memberof vf.gui.tween
	 */
	export const Interpolation: {
	    Linear(v: any, k: number, value: any): any;
	    Bezier(v: any, k: number, value: any): any;
	    CatmullRom(v: any, k: number, value: any): any;
	    Utils: {
	        Linear(p0: any, p1: any, t: any, v: any): any;
	        Reset(value: any): any;
	        Bernstein(n: any, i: any): number;
	        Factorial: (n: any) => number;
	        CatmullRom(p0: any, p1: any, p2: any, p3: any, t: any, v?: any): any;
	    };
	};

}
declare module 'src/event/TweenEvent' {
	/**
	 * 缓动事件
	 */
	export const TweenEvent: {
	    /**
	     *
	     */
	    Callback: string;
	    /**
	     * 每次改变
	     */
	    update: string;
	    /**
	     * 完成
	     */
	    complete: string;
	    /**
	     * 开始时
	     */
	    start: string;
	    /**
	     * 每次重复时
	     */
	    repeat: string;
	    /**
	     * 反向时
	     */
	    reverse: string;
	    /**
	     * 暂停时
	     */
	    pause: string;
	    /**
	     * 播放时
	     */
	    play: string;
	    /**
	     * 重新开始时
	     */
	    restart: string;
	    /**
	     * 停止时
	     */
	    stop: string;
	};

}
declare module 'src/tween/Tween' {
	///   types="@vf.js/vf" />
	import { add, get, getAll, remove, removeAll, removeDisplay, update } from 'src/tween/private/core';
	/**
	 * 缓动动画
	 *
	 * @example let tween = new vf.gui.Tween(myObject).to({width:'300px'}, 2000).start()
	 *
	 */
	export class Tween extends vf.utils.EventEmitter {
	    static core: {
	        add: typeof add;
	        get: typeof get;
	        getAll: typeof getAll;
	        remove: typeof remove;
	        removeAll: typeof removeAll;
	        removeDisplay: typeof removeDisplay;
	        update: typeof update;
	    };
	    static Event: {
	        Callback: string;
	        update: string;
	        complete: string;
	        start: string;
	        repeat: string;
	        reverse: string;
	        pause: string;
	        play: string;
	        restart: string;
	        stop: string;
	    };
	    /**
	     * Easier way to call the Tween
	     * @param {object} object - Initial value
	     * @param {object} to - Target value
	     * @param {object} params - Options of tweens
	     * @example Tween.fromTo(myObject, {x:0}, {x:200},1000)
	     * @memberof vf.gui.Tween
	     * @static
	     */
	    static fromTo(object: any, to: any, duration?: number): Tween;
	    /**
	     * Easier way calling constructor only applies the `to` value, useful for CSS Animation
	     * @param {any} object object
	     * @param {object} to - Target value
	     * @param {object} params - Options of tweens
	     * @example Tween.to(myObject, {x:200}, 1000)
	     * @memberof vf.gui.Tween
	     * @static
	     */
	    static to(object: any | any[], to: any, duration?: number): Tween;
	    /**
	     * Easier way calling constructor only applies the `from` value, useful for CSS Animation
	     * @param {any} object object
	     * @param {object} from - Initial value
	     * @param {object} params - Options of tweens
	     * @example Tween.from(myObject, {x:200}, 1000)
	     * @memberof vf.gui.Tween
	     * @static
	     */
	    static from(object: any, from: any, duration?: number): Tween;
	    constructor(object?: any);
	    id: number;
	    object: any;
	    private _valuesEnd;
	    private _valuesStart;
	    _virtualValueStart: any;
	    protected _duration: number;
	    private _easingFunction;
	    private _easingReverse;
	    private _interpolationFunction;
	    protected _startTime: number;
	    protected _delayTime: number;
	    private _repeat;
	    private _initRepeat;
	    _isPlaying: boolean;
	    private _yoyo;
	    private _reversed;
	    private _onStartCallbackFired;
	    private _isFinite;
	    private _prevTime;
	    private _rendered;
	    private _reverseDelayTime;
	    /** 附加数据 */
	    data: {
	        [key: string]: any;
	    };
	    /**
	     *
	     * 外部使用回调函数   这里用于timeLine给每个tween设置事件回调
	     */
	    onUpdate?: Function;
	    onUpdateParams?: any;
	    onStart?: Function;
	    onStartParams?: any;
	    onComplete?: Function;
	    onCompleteParams?: any;
	    onRepeat?: Function;
	    onRepeatParams?: any;
	    onReverseComplete?: Function;
	    onReverseCompleteParams?: any;
	    private _needDownGrade;
	    setObject(object: any): void;
	    onFunction(eventType: string, object: any, elapsed?: any): void;
	    get needDownGrade(): boolean;
	    set needDownGrade(value: boolean);
	    /**
	     * 是否在播放中
	     * @return {boolean}
	     * @example tween.isPlaying()
	     * @memberof vf.gui.Tween
	     */
	    get isPlaying(): boolean;
	    set isPlaying(value: boolean);
	    get valuesEnd(): any;
	    get valuesStart(): any;
	    /**
	     * 是否开始播放
	     * @return {boolean}
	     * @example tween.isStarted()
	     * @memberof vf.gui.Tween
	     */
	    get isStarted(): boolean;
	    get delayTime(): number;
	    /**
	     * 获取动画的开始时间
	     */
	    get startTime(): number;
	    /**
	     * 获取动画的开始时间
	     */
	    set startTime(value: number);
	    /**
	     * 设置缓动时长
	     * @param {number} amount 持续的毫秒值
	     * @example tween.duration(2000)
	     * @memberof vf.gui.Tween
	     * @deprecated 不推荐使用这个方法，内部使用
	     * @private
	     */
	    set duration(amount: number | Function);
	    get duration(): number | Function;
	    /**
	     * 逆向缓动
	     * @example tween.reverse()
	     * @param {boolean=} state 是否逆向
	     * @memberof vf.gui.Tween
	     */
	    reverse(state?: boolean, timer?: number): this;
	    /**
	     * 当前动画是否逆转
	     * @return {boolean}
	     * @example tween.reversed() true逆向中
	     * @memberof vf.gui.Tween
	     */
	    reversed(): boolean;
	    /**
	     * 暂停缓动
	     * @example tween.pause()
	     * @memberof vf.gui.Tween
	     */
	    pause(): boolean | this;
	    /**
	     * 播放或恢复播放
	     * @example tween.play()
	     * @memberof vf.gui.Tween
	     */
	    play(): boolean | this;
	    /**
	     * 设置要缓动的目标属性与持续时间
	     * @param {object} properties 目标属性值
	     * @param {number|Object=} [duration=1000] 持续时间
	     * @example let tween = new vf.gui.Tween({x:0}).to({x:100}, 2000)
	     * @memberof vf.gui.Tween
	     */
	    to(properties: any, duration?: number): this;
	    private render;
	    /**
	     * 开始执行缓动
	     * @example tween.start()
	     * @memberof vf.gui.Tween
	     */
	    start(): this;
	    private toEnd;
	    /**
	     * 停止缓动
	     * @example tween.stop()
	     * @memberof vf.gui.Tween
	     */
	    stop(): boolean | this;
	    /**
	     * 设置延迟执行时间
	     * @param {number} amount 延迟等待的时间，毫秒
	     * @example tween.delay(500)
	     * @memberof vf.gui.Tween
	     */
	    delay(amount: number): this;
	    /**
	     * 设置重复执行的次数
	     * @param {number} amount 重复次数
	     * @example tween.repeat(5)
	     * @memberof vf.gui.Tween
	     */
	    repeat(amount: number): this;
	    /**
	     * 设置每个重复执行过程的延迟时间，毫秒
	     * @param {number} amount 延迟值
	     * @example tween.reverseDelay(500)
	     * @memberof vf.gui.Tween
	     */
	    reverseDelay(amount: number): this;
	    /**
	     * 是否在重复执行中启用反向动画
	     * @param {boolean} state true启动
	     * @param {Function=} _easingReverse 反向时的Easing function
	     * @example tween.yoyo(true)
	     * @memberof vf.gui.Tween
	     */
	    yoyo(state?: boolean | Function, _easingReverse?: (k: number) => number): this;
	    /**
	     * 设置缓动函数
	     * @param {Function} _easingFunction 缓动函数的公式，如果设置yoyo的第二个值会应用于逆向缓动
	     * @example tween.easing(Easing.Elastic.InOut)
	     * @memberof vf.gui.Tween
	     */
	    easing(_easingFunction: ((k: number) => number) | any): this;
	    easingReverse(_easingReverse: ((k: number) => number) | any): this;
	    /**
	     * 设置差值
	     * @param {Function} _interpolationFunction 差值的函数
	     * @example tween.interpolation(Interpolation.Bezier)
	     * @memberof vf.gui.Tween
	     */
	    interpolation(_interpolationFunction: (v: any, k: number, value: any) => any): this;
	    /**
	     * 更新动画到指定时间点，进行播放
	     * @param time
	     */
	    gotoAndPlay(time: number): void;
	    /**
	     * 更新动画到指定时间点，停止播放
	     * @param time
	     */
	    gotoAndStop(time: number): void;
	    /**
	     * 更新动画到指定时间点，停止播放
	     * @param time
	     */
	    gotoAndEnd(): void;
	    /**
	     * 更新函数，通过给定的 `time` 设置目标属性变化
	    * @param {number=} deltaTime 帧间隔
	    * @param {Boolean=} preserve 完成后，防止删除动画对象
	     * @param {boolean=} forceTime 强制进行更新渲染，不关心时间是否匹配
	     * @example tween.update(100)
	     * @memberof vf.gui.Tween
	     */
	    update(deltaTime: number, preserve?: boolean, forceTime?: boolean): boolean;
	    release(): void;
	}

}
declare module 'src/core/Ticker' {
	 class Ticker extends vf.Ticker {
	    constructor();
	    start(): void;
	    currentTickerTime: number;
	    update(currentTime: number): void;
	    /**
	     * 时间穿越， 单位ms
	     * @param duration
	     */
	    timeTravel(duration: number): void;
	}
	export const TickerShared: Ticker;
	export {};

}
declare module 'src/tween/Timeline' {
	/**
	 * 基于帧的时间轴控制类
	    *
	 * @example let timeline = new vf.gui.Timeline();
	 *
	 */
	///   types="@vf.js/vf" />
	import { Tween } from 'src/tween/Tween';
	export class TimeLineDefaultData {
	    delay?: number;
	    paused?: boolean;
	    repeat?: number;
	    ease?: ((k: number) => number) | any;
	    yoyo?: boolean;
	    onStart?: Function;
	    onStartParams?: any;
	    onUpdate?: Function;
	    onUpdateParams?: any;
	    onRepeat?: Function;
	    onRepeatParams?: any;
	    onComplete?: Function;
	    onCompleteParams?: any;
	    onReverseComplete?: Function;
	    onReverseCompleteParams?: any;
	}
	export class TimeLineDataItem {
	    tween?: Tween;
	    positionTime: number;
	    hasPlay: boolean;
	}
	export class TimeLine extends vf.utils.EventEmitter {
	    private _defaultParam;
	    private _duration;
	    private _reactDuration;
	    private _objList;
	    private _propertyList;
	    private _tweens;
	    private _pauseTime;
	    private _pauseCallBack?;
	    private _pauseCallBackParam?;
	    private _currenTimer;
	    private _totalRepeat;
	    private _repeat;
	    private _playStates;
	    private _oldPlayStates;
	    private _tickIns;
	    private _isFinite;
	    private _needDownGrade;
	    constructor(options: TimeLineDefaultData);
	    set needDownGrade(value: boolean);
	    get needDownGrade(): boolean;
	    set onStart(value: any);
	    set onStartParams(value: any);
	    set onUpdate(value: any);
	    set onUpdateParams(value: any);
	    set onRepeat(value: any);
	    set onRepeatParams(value: any);
	    set onComplete(value: any);
	    set onCompleteParams(value: any);
	    set onReverseComplete(value: any);
	    set onReverseCompleteParams(value: any);
	    getDefaultParam(): any;
	    private set playStates(value);
	    get duration(): number;
	    get currenTimer(): number;
	    get reversed(): boolean;
	    get paused(): boolean;
	    /**
	     * 顺序播放
	     *
	     */
	    add(value: Tween, position?: number): this;
	    private cacheStartData;
	    private cacheStartDataTest;
	    private getNextValue;
	    private getPropertyList;
	    private toStartData;
	    /**
	     *
	     * 获取时刻数据
	     */
	    setTimeProries(timer: number): void;
	    /**
	     *
	     */
	    addPause(position?: number, callback?: Function, paranms?: any): this;
	    /**
	     * 相当于 add(TweenLite.to(...))
	     */
	    to(element: any, duration: number, options: any, position?: number): this;
	    /**
	     *
	     */
	    play(timer?: number): void;
	    /**
	     * 暂停
	     */
	    pause(): void;
	    /**
	     *
	     */
	    resume(): void;
	    /**
	     * 跳转
	     */
	    seek(timer: number): void;
	    /**
	     * 倒放
	     */
	    reverse(timer?: number): void;
	    /**
	     * 刷新
	     */
	    onUpdata(time: number): void;
	    private playUpdate;
	    private checkPause;
	    private tweenItemPlay;
	    private checkNextRepeat;
	    private checkTweensComplete;
	    private toNext;
	    private complete;
	    private stopAll;
	    release(): void;
	}

}
declare module 'src/tween/private/core' {
	import { Tween } from 'src/tween/Tween';
	import { TimeLine } from 'src/tween/Timeline';
	/**
	 * 插件存储器
	 * @memberof vf.gui.tween
	 * @example
	 * let num = Plugins.num = function (node, start, end) {
	  * return t => start + (end - start) * t
	  * }
	  *
	  * @static
	  */
	export const Plugins: any;
	/**
	 * 添加对象到缓动列表
	 * @param {Tween} tween Tween 实例
	 * @memberof vf.gui.tween
	 * @example
	 * let tween = new vf.gui.tween.Tween({x:0})
	 * tween.to({x:200}, 1000)
	 * vf.gui.tween.add(tween)
	 */
	export function add(tween: Tween): void;
	/**
	 * 没有缓动后，设置运行多少帧后，停止
	 * @param {number} frameCount=120 删除所有动画后，要运行的剩余帧
	 * @memberof vf.gui.tween
	 * @example
	 * vf.gui.tween.FrameThrottle(60)
	 */
	export function FrameThrottle(frameCount?: number): void;
	/**
	 * 延时处理，针对插件、canvas、dom
	 * @param {number} state=true 是否平滑处理
	 * @memberof vf.gui.tween
	 * @example
	 * vf.gui.tween.ToggleLagSmoothing(false)
	 */
	export function ToggleLagSmoothing(_state?: boolean): void;
	/**
	 * 获得所有缓动对象
	 * @memberof vf.gui.tween
	 * vf.gui.tween.getAll()
	 */
	export function getAll(): Tween[];
	/**
	 * 移除所有动画对象
	 * @example  vf.gui.tween.removeAll()
	 * @memberof vf.gui.tween
	 */
	export function removeAll(): void;
	/**
	 * 获取对象
	 * @param {Tween} tween 缓动对象实例
	 * @return {Tween} 返回对象或null
	 * @memberof vf.gui.tween
	 * @example
	 * vf.gui.tween.get(tween)
	 */
	export function get(tween: Tween): Tween | null;
	/**
	 * 从缓动列表移除对象
	 * @param {Tween} tween Tween instance
	 * @memberof vf.gui.tween
	 * @example
	 * vf.gui.tween.remove(tween)
	 */
	export function remove(tween: Tween): void;
	export function removeDisplay(uuid: string): void;
	/**
	 * 按给定时间更新缓动
	 * @param {number=} time 时间戳
	 * @param {Boolean=} preserve 完成后，防止删除动画对象
	 * @memberof vf.gui.tween
	 * @example
	 * vf.gui.tween.update(500)
	 */
	export function update(deltaTime: number): boolean;
	/**
	 * 是否正在运行中
	 * @return {Boolean} 只要还有缓动在运行，返回true
	 * @memberof vf.gui.tween
	 * @example vf.gui.tween.isRunning()
	 */
	export function isRunning(): boolean;
	/**
	 * 返回是否开启延迟平滑状态
	 * @return {Boolean}
	 * @memberof vf.gui.tween
	 * @example vf.gui.tween.isRunning()
	 */
	export function isLagSmoothing(): boolean;
	/**
	 * 添加到列表
	 */
	export function addTimeLine(timeLine: TimeLine): void;
	/**
	 * 移除列表
	 */
	export function removeTimeLine(timeLine: TimeLine): void;
	/**
	 * 销毁所有
	 */
	export function releaseAllTimeLine(): void;

}
declare module 'src/tween/private/index' {
	import { add, get, getAll, isRunning, FrameThrottle, ToggleLagSmoothing, Plugins, remove, removeAll, removeDisplay, update, addTimeLine, removeTimeLine, releaseAllTimeLine } from 'src/tween/private/core';
	import { Interpolation } from 'src/tween/private/Interpolation';
	import * as utils from 'src/tween/private/constants';
	import { TweenEvent } from 'src/event/TweenEvent';
	import { TimeLine } from 'src/tween/TimeLine';
	export { Plugins, get, getAll, removeAll, remove, removeDisplay, add, update, releaseAllTimeLine, addTimeLine, removeTimeLine, isRunning, FrameThrottle, ToggleLagSmoothing, Interpolation, TweenEvent, TimeLine, utils };

}
declare module 'src/core/DisplayLayoutKeys' {
	/** 标记属性失效 */
	export const invalidatePropertiesFlag: symbol;
	/** 标记大小失效 */
	export const invalidateSizeFlag: symbol;
	/** 标记显示失效 */
	export const invalidateDisplayListFlag: symbol;
	/** 是否参与布局 */
	export const includeInLayout: symbol;
	export const width: symbol;
	export const height: symbol;
	export const explicitWidth: symbol;
	export const explicitHeight: symbol;
	export const minWidth: symbol;
	export const maxWidth: symbol;
	export const minHeight: symbol;
	export const maxHeight: symbol;
	export const percentWidth: symbol;
	export const percentHeight: symbol;
	export const measuredWidth: symbol;
	export const measuredHeight: symbol;
	export const oldPreferWidth: symbol;
	export const oldPreferHeight: symbol;
	export const left: symbol;
	export const right: symbol;
	export const top: symbol;
	export const bottom: symbol;
	export const horizontalCenter: symbol;
	export const verticalCenter: symbol;

}
declare module 'src/core/DisplayLayoutValidator' {
	///   types="@vf.js/vf" />
	import { DisplayLayoutAbstract } from 'src/core/DisplayLayoutAbstract'; class UIValidator extends vf.utils.EventEmitter {
	    /**
	     * @private
	     * 创建一个Validator对象
	     */
	    constructor();
	    /**
	     * @private
	     */
	    private targetLevel;
	    /**
	     * @private
	     */
	    private invalidatePropertiesFlag;
	    /**
	     * @private
	     */
	    private invalidateClientPropertiesFlag;
	    /**
	     * @private
	     */
	    private invalidatePropertiesQueue;
	    /**
	     * @private
	     * 标记组件属性失效
	     */
	    invalidateProperties(target: DisplayLayoutAbstract): void;
	    /**
	     * @private
	     * 验证失效的属性
	     */
	    private validateProperties;
	    /**
	     * @private
	     */
	    private invalidateSizeFlag;
	    /**
	     * @private
	     */
	    private invalidateClientSizeFlag;
	    /**
	     * @private
	     */
	    private invalidateSizeQueue;
	    /**
	     * @private
	     * 标记需要重新测量尺寸
	     */
	    invalidateSize(target: DisplayLayoutAbstract): void;
	    /**
	     * @private
	     * 测量尺寸
	     */
	    private validateSize;
	    /**
	     * @private
	     */
	    private invalidateDisplayListFlag;
	    /**
	     * @private
	     */
	    private invalidateDisplayListQueue;
	    /**
	     * @private
	     * 标记需要重新布局
	     */
	    invalidateDisplayList(client: DisplayLayoutAbstract): void;
	    /**
	     * @private
	     * 重新布局
	     */
	    private validateDisplayList;
	    /**
	     * @private
	     * 是否已经添加了事件监听
	     */
	    private listenersAttached;
	    /**
	     * @private
	     * 添加事件监听
	     */
	    private attachListeners;
	    /**
	     * @private
	     * 执行属性应用
	     */
	    private doPhasedInstantiationCallBack;
	    /**
	     * @private
	     */
	    private doPhasedInstantiation;
	    /**
	     * @private
	     * 使大于等于指定组件层级的元素立即应用属性
	     * @param target 要立即应用属性的组件
	     */
	    validateClient(target: DisplayLayoutAbstract): void;
	    removeDepthQueueAll(): void;
	} const validatorShared: UIValidator;
	export default validatorShared;

}
declare module 'src/core/ContainerBase' {
	///   types="@vf.js/vf" />
	/** 容器扩展类，后续便于做延时渲染 */
	export class ContainerBase extends vf.Container {
	    constructor();
	    isEmitRender: boolean;
	    render(renderer: vf.Renderer): void;
	}

}
declare module 'src/core/plugs/LineGradient' {
	///   types="@vf.js/vf" />
	interface TextureFillParamType {
	    canvas?: HTMLCanvasElement;
	    context?: CanvasRenderingContext2D;
	    texture?: vf.Texture;
	    width: number;
	    height: number;
	    anchorX: number;
	    anchorY: number;
	    style: {
	        fillColor: number[] | number[][];
	        fillGradientStops: number[];
	        fillGradientType: 0 | 1;
	    };
	}
	/**
	 * 设置渐变
	 * @param type
	 * @param stops
	 * @param color
	 * @returns
	 */
	export function updateTextureFill(_display: vf.Graphics, fillParam: TextureFillParamType): TextureFillParamType | undefined;
	export {};

}
declare module 'src/core/Background' {
	export class Background {
	    constructor(parent: any);
	    private canvas?;
	    private context?;
	    private texture?;
	    private parent;
	    private _container?;
	    private _oldSrc;
	    private _oldRepeat;
	    private _rect?;
	    private _image?;
	    private _mask?;
	    private _invalidateFlag;
	    isInit: boolean;
	    private _type;
	    get type(): 0 | 1 | 2;
	    set type(value: 0 | 1 | 2);
	    private _color;
	    get color(): number | undefined;
	    set color(value: number | undefined);
	    private _alpha;
	    get alpha(): number;
	    set alpha(value: number);
	    private _radius;
	    get radius(): number;
	    set radius(value: number);
	    private _src;
	    get src(): string | undefined;
	    set src(value: string | undefined);
	    private _positionX;
	    get positionX(): number;
	    set positionX(value: number);
	    private _positionY;
	    get positionY(): number;
	    set positionY(value: number);
	    private _size;
	    get size(): number[] | undefined;
	    set size(value: number[] | undefined);
	    private _repeat;
	    get repeat(): "no-repeat" | "repeat";
	    set repeat(value: "no-repeat" | "repeat");
	    private _fillAlpha;
	    get fillColor(): number | undefined;
	    set fillColor(value: number | undefined);
	    private _fillGradientStops;
	    get fillGradientStops(): number[];
	    set fillGradientStops(value: number[]);
	    private _fillGradientType;
	    get fillGradientType(): 0 | 1;
	    set fillGradientType(value: 0 | 1);
	    private lastW?;
	    private lastH?;
	    update(w: number, h: number): void;
	    private drawRect;
	    private removeImage;
	    release(): void;
	}

}
declare module 'src/core/MaskSprite' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	export interface MaskSprite extends DisplayObject {
	    maskSprite(): vf.Sprite | vf.Graphics;
	}

}
declare module 'src/core/Mask' {
	///   types="@vf.js/vf" />
	import { MaskSprite } from 'src/core/MaskSprite';
	export class Mask {
	    constructor(parent: any);
	    private parent;
	    private _image?;
	    private _oldImage;
	    private _mask;
	    private _invalidateFlag;
	    private _position?;
	    get position(): number[] | undefined;
	    set position(value: number[] | undefined);
	    private _size;
	    get size(): number[] | undefined;
	    set size(value: number[] | undefined);
	    get image(): string | vf.Graphics | MaskSprite | undefined;
	    set image(value: string | vf.Graphics | MaskSprite | undefined);
	    update(w: number, h: number): void;
	    private getGuiObject;
	    release(): void;
	}

}
declare module 'src/core/DisplayObjectAbstract' {
	///   types="@vf.js/vf" />
	import { ContainerBase } from 'src/core/ContainerBase';
	import { Stage } from 'src/core/Stage';
	import { DisplayObject } from 'src/core/DisplayObject';
	import { Background } from 'src/core/Background';
	import { Mask } from 'src/core/Mask';
	export class DisplayObjectAbstract extends vf.utils.EventEmitter implements LifecycleHook, Lifecycle {
	    constructor();
	    /**
	     * 全局唯一ID
	     */
	    readonly uuid: number;
	    id: string;
	    /**
	     * 自定义组价名
	     */
	    name: string;
	    /**
	     * @private
	     * 这个对象在显示列表中的嵌套深度，舞台为1，它的子项为2，子项的子项为3，以此类推。当对象不在显示列表中时此属性值为0.
	     */
	    $nestLevel: number;
	    /**
	     * 是否初始化
	     * @default
	     */
	    initialized: boolean;
	    /**
	     * 舞台引用
	     */
	    $stage?: Stage;
	    /**
	     * 父容器
	     */
	    parent: DisplayObject | Stage | undefined;
	    /**
	     * 节点列表
	     */
	    uiChildren: DisplayObjectAbstract[];
	    /** 没有功能实现，内部编辑器 */
	    container: ContainerBase;
	    /**
	     * 背景(内部使用)
	     */
	    $background: Background;
	    /**
	     * 遮罩(内部使用)，设置遮罩后，组件内部的索引位置可能产生变化
	     */
	    $mask: Mask;
	    /**
	     * 是否开启事件同步
	     */
	    syncabled: boolean;
	    /**
	     * 是否开启恢复时派发事件
	     */
	    resumeabled: boolean;
	    /** 添加显示对象，需集成Core */
	    addChild<T extends DisplayObjectAbstract>(item: T): T;
	    /**
	     * 插入显示对象到特定位置
	     * @param item 显示对象
	     * @param index 要插入的索引，最大值为当前显示列表的长度，最小值为0
	     */
	    addChildAt<T extends DisplayObjectAbstract>(item: T, index: number): T;
	    getChildAt(index: number): DisplayObjectAbstract;
	    getChildByUUID(uuid: number): DisplayObjectAbstract | undefined;
	    _getChildById(id: string): DisplayObjectAbstract | undefined;
	    getChildByPath(ids: string[]): DisplayObjectAbstract | undefined;
	    /**
	     * 移除已添加的UI组件
	     * @param UIObject 要移除的UI组件
	     */
	    removeChild<T extends DisplayObjectAbstract>(item: T): T;
	    removeChildAt<T>(index: number): T;
	    /**
	     * 移除元素
	     * @param release 是否释放子节点，破坏结构
	     * @param beginIndex 开始
	     * @param endIndex 结束
	     */
	    removeChildren(release?: boolean, beginIndex?: number | undefined, endIndex?: number | undefined): void;
	    /**
	     * 是否绘制显示对象，如果false不进行绘制，不过仍然会进行相关的更新计算。
	     * 只影响父级的递归调用。
	     */
	    set renderable(value: boolean);
	    get renderable(): boolean;
	    private _interactive;
	    /**
	     * 对象是否可以接收事件
	     */
	    set interactive(value: boolean);
	    get interactive(): boolean;
	    private _interactiveChildren;
	    /**
	     * 子对象是否可以接收事件，设置false后，会绕过HitTest方法的递归
	     */
	    set interactiveChildren(value: boolean);
	    get interactiveChildren(): boolean;
	    /**
	     * 子类实现
	     */
	    validateNow(): void;
	    private _enabled;
	    get enabled(): boolean;
	    set enabled(value: boolean);
	    /**
	     * 是否可见
	     */
	    private _visible;
	    get visible(): boolean;
	    set visible(value: boolean);
	    /** 清除全部事件 */
	    offAll(event?: string | symbol): this;
	    get stage(): Stage | undefined;
	    protected checkInvalidateFlag(): void;
	    load(): void;
	    release(): void;
	    $onInit(): void;
	    $onLoad(): void;
	    $onRelease(): void;
	    $onAddStage(): void;
	    $onRemoveStage(): void;
	}

}
declare module 'src/core/DisplayLayoutAbstract' {
	///   types="@vf.js/vf" />
	import { DisplayObjectAbstract } from 'src/core/DisplayObjectAbstract';
	export const $tempLocalBounds: vf.Rectangle;
	/**
	 * UI 布局的基础属性类
	 */
	export class DisplayLayoutAbstract extends DisplayObjectAbstract {
	    constructor();
	    isContainer: boolean;
	    /**
	     * @private
	     */
	    $values: any;
	    /**
	     * @private
	     * 定义的所有变量请不要添加任何初始值，必须统一在此处初始化。
	     */
	    protected initializeUIValues(): void;
	    /**
	     * @private
	     * 检查属性失效标记并应用
	     */
	    protected checkInvalidateFlag(): void;
	    /**
	     * @private
	     * 验证组件的属性
	     */
	    validateProperties(): void;
	    /**
	     * @private
	     * 验证组件的尺寸
	     */
	    validateSize(recursive?: boolean): void;
	    /**
	     * @private
	     * 验证子项的位置和大小，并绘制其他可视内容
	     */
	    validateDisplayList(): void;
	    /**
	     * @private
	     * 提交属性，子类在调用完invalidateProperties()方法后，应覆盖此方法以应用属性
	     */
	    protected commitProperties(): void;
	    /**
	     * 测量显示对象宽高，如果子类没有重写，默认是this.container.width..
	     */
	    protected measure(): void;
	    /**
	     * @private
	     * 测量组件尺寸，返回尺寸是否发生变化
	     */
	    protected measureSizes(): boolean;
	    /**
	     * @private
	     *
	     * @returns
	     */
	    protected getPreferredUWidth(): number;
	    /**
	     * @private
	     */
	    protected getPreferredUHeight(): number;
	    /**
	     * @private
	     * 获取组件的首选尺寸,常用于父级的measure()方法中
	     * 按照：外部显式设置尺寸>测量尺寸 的优先级顺序返回尺寸，
	     */
	    getPreferredBounds(bounds: vf.Rectangle): vf.Rectangle;
	    /**
	    * @private
	    * 标记提交过需要延迟应用的属性，以便在稍后屏幕更新期间调用该组件的 commitProperties() 方法。
	    *
	    * 例如，要更改文本颜色和大小，如果在更改颜色后立即进行更新，然后在设置大小后再更新大小，就有些浪费。
	    * 同时更改两个属性后再使用新的大小和颜色一次性呈示文本，效率会更高。<p/>
	    *
	    * 通常，子类应覆盖 commitProperties() 方法，而不是覆盖此方法。
	     */
	    invalidateProperties(): void;
	    /**
	    * @private
	    * 标记提交过需要验证组件尺寸，以便在稍后屏幕更新期间调用该组件的 measure(),updatesize() 方法。
	    */
	    invalidateSize(): void;
	    /**
	    * @private
	    * 标记需要验证显示列表，以便在稍后屏幕更新期间调用该组件的 updateDisplayList() 方法。
	    */
	    invalidateDisplayList(): void;
	    /**
	     * @private
	     * 标记父级容器的尺寸和显示列表为失效
	     */
	    invalidateParentLayout(): void;
	    /**
	     * @private
	     * 设置组件的布局位置
	     */
	    setPosition(x?: number | undefined, y?: number | undefined): void;
	    /**
	     * @private
	     * 设置测量结果。
	     * @param width 测量宽度
	     * @param height 测量高度
	     */
	    setMeasuredSize(width: number, height: number): void;
	    /**
	     * @private
	     * 设置组件的宽高。此方法不同于直接设置width,height属性，
	     * 不会影响显式标记尺寸属性
	     */
	    setActualSize(w: number, h: number, isInvalidate?: boolean): void;
	    updateTransform(): void;
	    /**
	     * 更新背景
	     */
	    protected updateBackground(unscaledWidth: number, unscaledHeight: number): void;
	    /**
	     * 更新遮罩
	     */
	    protected updateMask(unscaledWidth: number, unscaledHeight: number): void;
	    /**
	     * @private
	     * 更新最终的组件宽高
	     */
	    protected updateSize(): void;
	    /**
	     * 更新显示列表,子类重写，实现布局
	     */
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    /**
	     * @private
	     * 立即应用组件及其子项的所有属性
	     */
	    validateNow(): void;
	    /**
	     * @private
	    * 验证并更新此对象的属性和布局，如果需要的话重绘对象。
	    *
	    * 通常只有当脚本执行完毕后，才会处理要求进行大量计算的处理属性。<p/>
	    *
	    * 例如，对 width 属性的设置可能会延迟，因为此设置需要重新计算这些对象的子项或父项的宽度。
	    * 如果脚本多次设置了 width 属性，则延迟处理可防止进行多次处理。此方法允许您手动覆盖此行为。
	     */
	    validateSizeNow(): void;
	    /**
	     * 指定此组件是否包含在父容器的布局中。若为false，则父级容器在测量和布局阶段都忽略此组件。默认值为true。
	     * 注意，visible属性与此属性不同，设置visible为false，父级容器仍会对其布局。
	     */
	    get includeInLayout(): boolean;
	    set includeInLayout(value: boolean);
	    /**
	     * @private
	     * 距父级容器离左边距离
	     */
	    get left(): any;
	    set left(value: any);
	    /**
	     * @private
	     * 距父级容器右边距离
	     */
	    get right(): any;
	    set right(value: any);
	    /**
	     * @private
	     * 距父级容器顶部距离
	     */
	    get top(): any;
	    set top(value: any);
	    /**
	     * @private
	     * 距父级容器底部距离
	     */
	    get bottom(): any;
	    set bottom(value: any);
	    /**
	     * @private
	     * 在父级容器中距水平中心位置的距离
	     */
	    get horizontalCenter(): any;
	    set horizontalCenter(value: any);
	    /**
	     * @private
	     * 在父级容器中距竖直中心位置的距离
	     */
	    get verticalCenter(): any;
	    set verticalCenter(value: any);
	    /**
	     * @private
	     * 相对父级容器宽度的百分比
	     */
	    get percentWidth(): number;
	    set percentWidth(value: number);
	    /**
	     * @private
	     * 相对父级容器高度的百分比
	     */
	    get percentHeight(): number;
	    set percentHeight(value: number);
	    /**
	     * @private
	     * 外部显式指定的宽度
	     */
	    get explicitWidth(): number;
	    /**
	     * @private
	     * 外部显式指定的高度
	     */
	    get explicitHeight(): number;
	    /**
	     * @private
	     * 组件的最小宽度,此属性设置为大于maxWidth的值时无效。同时影响测量和自动布局的尺寸。
	     */
	    get minWidth(): number;
	    set minWidth(value: number);
	    /**
	     * @private
	     * 组件的最大高度。同时影响测量和自动布局的尺寸。
	     */
	    get maxWidth(): number;
	    set maxWidth(value: number);
	    /**
	     * @private
	     * 组件的最小高度,此属性设置为大于maxHeight的值时无效。同时影响测量和自动布局的尺寸。
	     */
	    get minHeight(): number;
	    set minHeight(value: number);
	    /**
	     * @private
	     * 组件的最大高度,同时影响测量和自动布局的尺寸。
	     */
	    get maxHeight(): number;
	    set maxHeight(value: number);
	    allInvalidate(): void;
	    /**
	     * @private
	     * 组件宽度设置为undefined将使用组件的measure()方法自动计算尺寸
	     */
	    get width(): number;
	    /**
	     * @private
	     *
	     * @param value
	     */
	    set width(value: number);
	    /**
	     * @private
	     * 组件高度,默认值为NaN,设置为NaN将使用组件的measure()方法自动计算尺寸
	     */
	    get height(): number;
	    /**
	     * @private
	     *
	     * @param value
	     */
	    set height(value: number);
	    get scaleX(): number;
	    set scaleX(value: number);
	    get scaleY(): number;
	    set scaleY(value: number);
	    get x(): number;
	    set x(value: number);
	    get y(): number;
	    set y(value: number);
	    get skewX(): number;
	    set skewX(value: number);
	    get skewY(): number;
	    set skewY(value: number);
	    get pivotX(): number;
	    set pivotX(value: number);
	    get pivotY(): number;
	    set pivotY(value: number);
	    get rotation(): number;
	    set rotation(value: number);
	    /**
	     *  =不可用= 设置索引层级，每次父级变化时，会排序 （未实现）
	     */
	    get zIndex(): number;
	    set zIndex(value: number);
	}

}
declare module 'src/event/EventType' {
	export const enum EventType {
	    /**
	     * 状态变化 ：IVFData -> VFStateCode
	     */
	    STATUS = "status",
	    /**
	     * 推送消息到外部
	     */
	    MESSAGE = "message",
	    /**
	     * 接收外部消息
	     */
	    ONMESSAGE = "onMessage",
	    /**
	     * 通用状态变化
	     */
	    STATE = "state",
	    /**
	     * 启动/开始
	     */
	    START = "start",
	    /**
	     * 心跳
	     */
	    TICK = "tick",
	    /**
	     * 更新
	     */
	    UPDATE = "update",
	    /**
	     * 已改变
	     */
	    CHANGED = "changed",
	    /**
	     * 结束
	     */
	    END = "end"
	}

}
declare module 'src/event/EventLevel' {
	/**
	 * status: 状态变化
	 *
	 * command: 执行操作
	 *
	 * ----------------------
	 *
	 * Info: 默认的等级
	 *
	 * Warn: 表示可能对系统有损害的情况
	 *
	 * 表示非常严重的错误等级，记录极有可能导致应用程序终止运行的致命错误信息；
	 */
	export const enum EventLevel {
	    /**
	     * 状态
	     */
	    STATUS = "status",
	    /**
	     * 命令
	     */
	    COMMAND = "command",
	    /**
	     * 默认的等级
	     */
	    INFO = "info",
	    /**
	     * 警告
	     */
	    WARNING = "warning",
	    /**
	     * 错误
	     */
	    ERROR = "error",
	    /**
	     * 原生
	     */
	    NATIVE = "native"
	}

}
declare module 'src/core/Scheduler' {
	///   types="@vf.js/vf" />
	/**
	 * Schedule anything
	 *
	 * @author 8088
	 */
	export class Scheduler extends vf.utils.EventEmitter {
	    get id(): number;
	    static schedulerList: Scheduler[];
	    static stopAll(): void;
	    static setEnterFrame(listener: (data?: any) => void): Scheduler;
	    static setInterval(time: number, listener: (data?: any) => void): Scheduler;
	    static setTimeout(time: number, listener: (data?: any) => void): Scheduler;
	    _interval: number;
	    _timeout: number;
	    private _id;
	    private _running;
	    private _pausing;
	    private _totalDuration;
	    private _intervalDuration;
	    constructor(timeout?: number, interval?: number);
	    restart(): void;
	    stop(): void;
	    pause(): void;
	    resume(): void;
	    private run;
	}

}
declare module 'src/core/Stage' {
	///   types="@vf.js/vf" />
	import { DisplayLayoutAbstract } from 'src/core/DisplayLayoutAbstract';
	import { SyncManager } from 'src/interaction/SyncManager';
	/**
	 * UI的舞台对象，展示所有UI组件
	 *
	 * @class
	 * @param width {Number} 舞台宽度
	 * @param height {Number} 舞台高度
	 */
	export class Stage extends DisplayLayoutAbstract {
	    constructor(width: number, height: number, app: vf.Application);
	    app: vf.Application;
	    syncManager: SyncManager | undefined;
	    resumeStatusFlag: boolean;
	    /**
	     * 是否组织原始数据继续传递
	     */
	    originalEventPreventDefault: boolean;
	    get stageWidth(): number;
	    get stageHeight(): number;
	    get scaleX(): number;
	    set scaleX(value: number);
	    get scaleY(): number;
	    set scaleY(value: number);
	    set Scale(value: vf.Point);
	    /**
	     * 是否同步交互事件
	     */
	    private _syncInteractiveFlag;
	    set syncInteractiveFlag(value: boolean);
	    get syncInteractiveFlag(): boolean;
	    getSystemEvent(): vf.utils.EventEmitter;
	    sendToPlayer(e: any): void;
	    release(): void;
	    releaseAll(): void;
	    resize(): void;
	    /**
	     * 接收来自player的消息
	     * @param msg
	     */
	    receiveFromPlayer(msg: any): void;
	    /**
	     * 截图功能
	     */
	    private _virCanvas;
	    private getVitualCanvas;
	    screenShots(x: number, y: number, width: number, height: number, endWidth?: number, endHeight?: number, displayObject?: vf.DisplayObject): vf.Texture;
	}

}
declare module 'src/enum/FollowLineEnum' {
	export const enum Role {
	    /** 老师 */
	    teacher = "T",
	    /** 学生 */
	    student = "S"
	}
	export const enum Operate {
	    add = "1",
	    remove = "2",
	    clear = "3"
	}

}
declare module 'src/interaction/SyncManager' {
	/**
	 * 用于同步输入事件
	 * by ziye
	 */
	///   types="@vf.js/vf" />
	import { InteractionEvent } from 'src/event/InteractionEvent';
	import { Stage } from 'src/core/Stage';
	import { DisplayObjectAbstract } from 'src/core/DisplayObjectAbstract';
	import { Role } from 'src/enum/FollowLineEnum';
	export class SyncManager extends vf.utils.EventEmitter {
	    constructor(stage: Stage);
	    /**
	     * 对应一个stage有一个syncManager的实例
	     */
	    static getInstance(stage?: Stage | undefined): SyncManager | undefined;
	    static getIns(): SyncManager | undefined;
	    static instance?: SyncManager;
	    private _role;
	    mode: number;
	    resumeStatusFlag: boolean;
	    resumeImmediately: boolean;
	    offsetTime: number;
	    private _initTime;
	    private _interactionEvent;
	    private _stage;
	    private _lostMoveEvent;
	    private _throttleMoveFlag;
	    private _throttleMoveTimer;
	    private _evtDataList;
	    private _readystate;
	    private _sendId;
	    private _lastSId;
	    private _lastTId;
	    private _lastSEventData;
	    private _lastTEventData;
	    private _swaitingEventList;
	    private _twaitingEventList;
	    private _waitTimer;
	    private _resumeTimer;
	    private _heartTimer;
	    private _autoHeartTimer;
	    autoHeartFlag: any;
	    _initDataTimer: number;
	    initDataFlag: boolean;
	    private _resumeStoreList;
	    private _startFlag;
	    private _lostEvent;
	    private _throttleEventTimer;
	    private _lastEventData?;
	    /**
	     * log
	     */
	    private log;
	    /**
	     * 清理syncManager
	     */
	    stop(): void;
	    /**
	     * 开始同步
	     */
	    start(): void;
	    /**
	     * 重置syncManager
	     */
	    private reset;
	    /**
	     * 角色
	     */
	    set role(value: Role);
	    get role(): Role;
	    /**
	     * 自动心跳，自动心跳基于每次输入操作之后，心跳10次，间隔0.5
	     * @param duration
	     * @param role
	     */
	    private autoHeartEvent;
	    /**
	     * 同步心跳
	     * @duration 心跳间隔
	     * @role 1-老师  2-学生   12-老师学生均发心跳
	     */
	    syncHeartEvent(duration: number, role?: number): void;
	    /**
	     * 发送心跳
	     */
	    sendHeartEvent(): void;
	    /**
	     * 收集交互事件
	     */
	    collectEvent(e: InteractionEvent, obj: DisplayObjectAbstract): void;
	    /**
	     * 发送自定义事件
	     * customData 自定义数据
	     */
	    sendCustomEvent(customData: any): void;
	    /**
	     * 发送当前时间
	     */
	    private sendSyncTimeEvent;
	    /**
	     * 接收操作
	     * @signalType 信令类型  live-实时信令   history-历史信令
	     */
	    receiveEvent(eventData: any, signalType?: string): void;
	    private dealLiveEvent;
	    /**
	     * 检查eventId是否正确
	     */
	    private checkEventId;
	    /**
	     * 检查是否有暂存的event需要执行
	     * forceFlag: 是否强制执行
	     */
	    private checkWaitingEvent;
	    /**
	     * 获取当前时间
	     */
	    private currentTime;
	    /**
	     * 构造一个新的e，用于同步，数据要尽量精简
	     */
	    private createEventData;
	    /**
	     * 发送操作(稀疏前的每一次单条发送)
	     */
	    private sendEvent;
	    /**
	     * 智能检测，如果是end，把所有暂存的一起立即发送
	     * 如果是start的，暂存起来，启动300ms的定时
	     * 如果是其他的，已经有暂存，则将继续暂存，否则立即发送
	     * @param eventData
	     */
	    private checkEventData;
	    private dealLostEvent;
	    /**
	     * 真实发送(稀疏后的真实发送，可能是单条，可能是数组)
	     */
	    private realSendEvent;
	    /**
	     * 更新节流状态
	     */
	    private throttleUpdate;
	    /**
	     * 节流，每100ms发送一次
	     * @param eventData
	     */
	    private throttle;
	    private resetStage;
	    /**
	     * 解析收到的event
	     */
	    private parseEventData;
	    /**
	     * 时间未到，需要穿越到未来
	     */
	    private timeTravel;
	    /**
	     * 模板初始化
	     * @param history
	     */
	    private initData;
	    /**
	     * 处理历史信令，将历史输入事件按时间顺序放置到一个数组
	     * @param eventData
	     */
	    private dealHistoryEvent;
	    private resumeStatusImmediately;
	    /**
	     * 恢复状态
	     */
	    private resumeStatus;
	    private resetCallback;
	}

}
declare module 'src/interaction/ClickEvent' {
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 * 点击触摸相关的事件处理订阅类,UI组件内部可以创建此类实现点击相关操作
	 *
	 *  可侦听事件:
	 * ```
	 *  {InteractionEvent}.TouchEvent.onHover
	 *  {InteractionEvent}.TouchEvent.onPress
	 *  {InteractionEvent}.TouchEvent.onClick
	 *  {InteractionEvent}.TouchEvent.onMove
	 * ```
	 *
	 * @example 可查看 `TestSliceSprite` 示例
	 *
	 * @since 1.0.0
	 */
	export class ClickEvent {
	    /**
	     * ClickEvent 构造函数
	     * @param obj 调用的显示对象
	     * @param includeHover 是否监听鼠标移上与移出，默认true
	     * @param rightMouseButton 是否开启鼠标右键点击，默认false
	     * @param doubleClick 是否开启鼠标双击,默认false
	     */
	    constructor(obj: DisplayObject, includeHover?: boolean, rightMouseButton?: boolean, doubleClick?: boolean);
	    /** 当前按下状态的所有对象，为了弹起统一做处理 */
	    private static downObjects;
	    private obj;
	    id: number;
	    /** 是否开启本地坐标转换，开启后，事件InteractionEvent中的localX localY为本地坐标，false情况下为0 */
	    isOpenLocalPoint: boolean;
	    private localOffset;
	    private offset;
	    private movementX;
	    private movementY;
	    private ishover;
	    private mouse;
	    private bound;
	    private right;
	    private hover;
	    double: boolean;
	    private time;
	    private isStop;
	    private deviceType;
	    getTarget(): DisplayObject;
	    startEvent(): void;
	    private _onStageTouchOutside;
	    private _onMouseRight;
	    /** 清除拖动 */
	    stopEvent(): void;
	    private _onMouseDown;
	    private emitTouchEvent;
	    private _mouseUpAll;
	    private _onMouseUp;
	    private _onMouseUpOutside;
	    private _onMouseOver;
	    private _onMouseOut;
	    private _tempMovePoint;
	    private _onMouseMove;
	    private setLocalPoint;
	    private removeAllMove;
	    remove(): void;
	}

}
declare module 'src/interaction/DragDropController' {
	import { DisplayObject } from 'src/core/DisplayObject';
	import { InteractionEvent } from 'src/event/InteractionEvent';
	/**
	 * 记录当前正在拖动的UI组件列表
	 * @private
	 */
	export const _items: DisplayObject[];
	export const _dropTargets: any[];
	/**
	 * 添加拖动组件到控制器
	 * @param item 要添加的UI组件
	 * @param e 传送的事件
	 * @returns true|false
	 * @since 1.0.0
	 */
	export function add(item: DisplayObject, e: InteractionEvent): boolean;
	export function remove(item: DisplayObject): boolean;
	/**
	 * 添加掉落容器
	 * @param group
	 * @param target
	 */
	export function addDropTarget(group: string, target: DisplayObject): void;
	/**
	 * 获取对应的掉落容器
	 * @param group
	 */
	export function getDropTargets(group: string): DisplayObject[];
	export function removeDropTarget(target: DisplayObject): void;
	/**
	 * 获取正在拖动组件
	 * @param item 要获取的UI组件
	 * @returns flase | item
	 */
	export function getItem(item: DisplayObject): false | DisplayObject;
	/**
	 * 根据事件对象与分组名获取拖动项
	 * @param e 事件对象
	 * @param group 分组名
	 */
	export function getEventItem(e: InteractionEvent, group: string | undefined): false | DisplayObject | null;

}
declare module 'src/interaction/DragEvent' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { InteractionEvent } from 'src/event/InteractionEvent';
	/**
	 * 多拽相关的事件处理类
	 *
	 *  可侦听事件:
	 * ```
	 *  {InteractionEvent}.DraggableEvent.onDragPress
	 *  {InteractionEvent}.DraggableEvent.onDragStart
	 *  {InteractionEvent}.DraggableEvent.onDragMove
	 *  {InteractionEvent}.DraggableEvent.onDragEnd
	 * ```
	 *  可赋值方法:
	 * ```
	 * onPress: ((e: InteractionEvent, isPressed: boolean,dragObj?: DragEvent) => void) | undefined;
	 * onDragEnd: ((e: InteractionEvent,dragObj?: DragEvent) => void) | undefined
	 * onDragMove: ((e: InteractionEvent, offset: vf.Point,dragObj?: DragEvent) => void) | undefined
	 * onDragStart: ((e: InteractionEvent,dragObj?: DragEvent) => void) | undefined
	 * ```
	 *
	 * @example 可查看 `Slider` 源码
	 *
	 * @since 1.0.0
	 */
	export class DragEvent {
	    constructor(obj: DisplayObject);
	    private obj;
	    id: number;
	    private offset;
	    private movementX;
	    private movementY;
	    private bound;
	    start: vf.Point;
	    private mouse;
	    private cancel;
	    private dragging;
	    private isStop;
	    private ishover;
	    /**
	     * 限制拖动抽,XY,X抽或Y抽
	     */
	    dragRestrictAxis?: "x" | "y";
	    startEvent(): void;
	    executeAction(e: InteractionEvent): void;
	    private _onDragOver;
	    private _onMouseOut;
	    private _onDragStart;
	    private _onDragMove;
	    private _onDragEnd;
	    /** 清除拖动 */
	    stopEvent(): void;
	    remove(): void;
	    onDragPress: ((e: InteractionEvent, isPressed: boolean, dragObj?: DragEvent) => void) | undefined;
	    onDragEnd: ((e: InteractionEvent, dragObj?: DragEvent) => void) | undefined;
	    onDragMove: ((e: InteractionEvent, offset: vf.Point, dragObj?: DragEvent) => void) | undefined;
	    onDragStart: ((e: InteractionEvent, dragObj?: DragEvent) => void) | undefined;
	    onDragHover: ((e: InteractionEvent, isHover: boolean, dragObj?: DragEvent) => void) | undefined;
	}

}
declare module 'src/display/Label' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 * 文本
	 *
	 * 中文换行特殊处理 xxxx.style.breakWords = true;
	 *
	 * 当文本容器设置宽高后，文字默认会根据文本容器宽高居中.
	 *
	 * 当文本容器设置宽高后，可通过 style.textAlign 进行文字位置调整
	 *
	 * @example let label = new vf.gui.Label();
	 *
	 */
	export class Label extends DisplayObject {
	    readonly sprite: vf.Text;
	    private _lineGraphics;
	    private _textDecorationWidth;
	    private _textDecorationStyle;
	    private _textAlpha;
	    private readonly _defaultColor;
	    private _color?;
	    constructor(text?: string);
	    private get widthNoShadow();
	    private get heightNoShadow();
	    private onWidthChange;
	    /**
	     * 设置分辨力比例
	     */
	    get resolution(): number;
	    set resolution(value: number);
	    get fillColor(): number[] | number[][];
	    set fillColor(value: number[] | number[][]);
	    set fillAlpha(value: number);
	    /**
	     * 文本颜色
	     */
	    get color(): string | number | number[] | string[] | undefined;
	    set color(value: string | number | number[] | string[] | undefined);
	    /**
	     * 文字透明度
	     */
	    get textAlpha(): number;
	    set textAlpha(value: number);
	    get textDecorationStyle(): 'Solid' | 'Double';
	    set textDecorationStyle(value: 'Solid' | 'Double');
	    /**
	     * 文本内容
	     */
	    get text(): string;
	    set text(value: string);
	    set fontCssStyle(value: any);
	    private setLine;
	    private showUnderLine;
	    private autoDrawLine;
	    private getStartPosX;
	    private getStartPosY;
	    private drawLine;
	    /**
	     * 测量显示对象宽高，如果子类没有重写，默认是this.container.width..
	     */
	    protected measure(): void;
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    private cacheOldData;
	    private clearLineGraphics;
	    release(): void;
	}

}
declare module 'src/utils/GifReader' {
	export class GifReader {
	    private _width;
	    private _height;
	    private _frames;
	    private _loop_count;
	    private _buf;
	    constructor(arrayBuffer: ArrayBuffer);
	    get width(): number;
	    get height(): number;
	    get numFrames(): number;
	    get loopCount(): number;
	    getFrameInfo(frame_num: number): FrameInfo;
	    decodeAndBlitFrameBGRA(frame_num: number, pixels: Uint8ClampedArray): FrameInfo;
	    decodeAndBlitFrameRGBA(frame_num: number, pixels: Uint8ClampedArray): FrameInfo;
	}
	export interface FrameInfo {
	    x: number;
	    y: number;
	    width: number;
	    height: number;
	    has_local_palette: boolean;
	    palette_offset: number;
	    palette_size: number;
	    data_offset: number;
	    data_length: number;
	    transparent_index: number;
	    interlaced: boolean;
	    delay: number;
	    disposal: number;
	}

}
declare module 'src/utils/GifFrames' {
	///   types="@vf.js/vf" />
	import { GifReader } from 'src/utils/GifReader';
	export class GifFrames {
	    private _frames;
	    private _gif;
	    constructor(_resource: vf.LoaderResource | ArrayBuffer);
	    private calcSingleTextureWidth;
	    get gif(): GifReader;
	    get frames(): Array<GifFrame>;
	    private generateTextureFromGifData;
	    get numFrames(): number;
	    getFrame(index: number): GifFrame;
	}
	export class GifFrame {
	    index: number;
	    texture: vf.Texture;
	    delayTime: number;
	    constructor(index: number, texture: vf.Texture, delayTime: number);
	}

}
declare module 'src/utils/GifSequence' {
	import { GifSprite } from 'src/display/private/GifSprite';
	import { GifFrame } from 'src/utils/GifFrames';
	export class GifSequence {
	    sprite: GifSprite;
	    name: string;
	    frames: Array<GifFrame>;
	    loopCount: number;
	    private _playing;
	    private _nextFrameTime;
	    private _loopedCount;
	    private _speedScale;
	    private _timeDistance;
	    constructor(sprite: GifSprite, name: string, frames: Array<GifFrame>, loopCount: number);
	    setEndlessLoop(): void;
	    get speedScale(): number;
	    set speedScale(value: number);
	    get duration(): number;
	    get playing(): boolean;
	    stop(skipEmit?: boolean): void;
	    play(): boolean;
	    private get currentFrameIndex();
	    get loopedCount(): number;
	    private update;
	}

}
declare module 'src/display/private/GifSprite' {
	///   types="@vf.js/vf" />
	import { GifFrame, GifFrames } from 'src/utils/GifFrames';
	import { GifSequence } from 'src/utils/GifSequence';
	export class GifSprite extends vf.Sprite {
	    static EVENT: {
	        FRAME_CHANGED: string;
	        PLAY: string;
	        STOP: string;
	        COMPLETE: string;
	        END: string;
	    };
	    private _frames;
	    private _sequences;
	    private _currentSequence;
	    private _currentFrame;
	    constructor(resource: vf.LoaderResource | string | GifFrames);
	    get gifFrames(): GifFrames;
	    get totalFrames(): number;
	    getSequence(name?: string): GifSequence;
	    addSequence(name: string, frames: Array<number>, loopCount?: number): GifSequence;
	    private _addSequence;
	    setSequence(name: string, play?: boolean): void;
	    destroy(): void;
	    play(): void;
	    stop(): void;
	    setFrame(frame: number): void;
	    setGifFrame(frame: GifFrame): void;
	    gotoAndStop(frame: number): void;
	    gotoAndPlay(frame: number): void;
	    get currentFrame(): number;
	    get currentGifFrame(): GifFrame;
	    get currentSequence(): GifSequence;
	    get playing(): boolean;
	    get speedScale(): number;
	    set speedScale(value: number);
	}

}
declare module 'src/display/Image' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { MaskSprite } from 'src/core/MaskSprite';
	import { GifSprite } from 'src/display/private/GifSprite';
	/**
	 * 图片
	 *
	 * @example let image = new vf.gui.Image();
	 *
	 */
	export class Image extends DisplayObject implements MaskSprite {
	    constructor();
	    /** 可以支持遮罩的组件 */
	    maskSprite(): vf.Sprite;
	    protected _sprite: vf.Sprite | vf.TilingSprite | vf.NineSlicePlane | GifSprite | undefined;
	    protected _texture: vf.Texture | undefined;
	    protected _source: number | string | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | undefined;
	    /**
	     * 图像路径或位图对象
	     */
	    private _src;
	    private _oldSrc?;
	    get src(): number | string | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | undefined;
	    set src(value: number | string | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | undefined);
	    private _isGif;
	    private _scale9Grid?;
	    private _oldScale9Grid?;
	    /**
	     * 矩形区域，它定义素材对象的九个缩放区域。
	     *
	     * fillMode = scale 时，[leftWidth,rightWidth,topHeight,bottomHeight]
	     *
	     * fillMode = repeat 是，[scalex,scaley,x,y]
	     */
	    get scale9Grid(): any[] | number[] | undefined;
	    set scale9Grid(value: any[] | number[] | undefined);
	    private _fillMode?;
	    private _oldFillMode?;
	    /**
	     * 填充模式
	     * 设置scale后，可设置scale9Grid进行调整缩放区域
	     */
	    get fillMode(): "repeat" | "no-repeat" | "scale" | undefined;
	    set fillMode(value: "repeat" | "no-repeat" | "scale" | undefined);
	    /**
	     * 锚点，调整位图的坐标中点 0-1
	     */
	    get anchorX(): number;
	    set anchorX(value: number);
	    /**
	     * 锚点，调整位图的坐标中点 0-1
	     */
	    get anchorY(): number;
	    set anchorY(value: number);
	    setSpeiteSize(unscaledWidth?: number, unscaledHeight?: number): void;
	    protected measure(): void;
	    protected srcSystem(): void;
	    protected commitProperties(): void;
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    release(): void;
	}

}
declare module 'src/display/private/InputBase' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { ClickEvent, InteractionEvent } from 'src/interaction/Index';
	/**
	 * 输入对象的基础类
	 */
	export class InputBase extends DisplayObject {
	    constructor();
	    /** 是否开启鼠标或触摸点击，开启后，接收TouchMouseEvent */
	    get interactabled(): boolean;
	    set interactabled(value: boolean);
	    protected clickEvent: ClickEvent;
	    private _currentState;
	    protected get currentState(): "up" | "move" | "down" | "disabled";
	    protected set currentState(value: "up" | "move" | "down" | "disabled");
	    protected _tabIndex: undefined | number;
	    protected _tabGroup: undefined | string;
	    protected _focused: boolean;
	    protected _useTab: boolean;
	    protected _usePrev: boolean;
	    protected _useNext: boolean;
	    protected _down: boolean;
	    private _clickSound?;
	    get clickSound(): string | undefined;
	    set clickSound(value: string | undefined);
	    set double(value: boolean);
	    get double(): boolean;
	    private _useMoveEvent;
	    set useMoveEvent(value: boolean);
	    get useMoveEvent(): boolean;
	    /**
	     * 状态皮肤，
	     */
	    up?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    /**
	     * 状态皮肤，
	     */
	    down?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    /**
	     * 状态皮肤，
	     */
	    move?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    /**
	     * 状态皮肤，
	     */
	    disabled?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    /**
	     * 选中状态皮肤，
	     */
	    upAndSelected?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    /**
	     * 选中状态皮肤，
	     */
	    downAndSelected?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    /**
	     * 选中状态皮肤，
	     */
	    moveAndSelected?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    /**
	     * 选中状态皮肤，
	     */
	    disabledAndSelected?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    protected onMove(): void;
	    protected onHover(): void;
	    protected onPress(e: InteractionEvent, thisObj: DisplayObject, isPress: boolean): void;
	    protected onClick(e: InteractionEvent): void;
	    protected keyDownEvent(event: WheelEvent | Event): void;
	    protected documentMouseDown(): void;
	    private keyDownEventBind;
	    protected _bindEvents(): void;
	    protected _clearEvents(): void;
	    focus(): void;
	    blur(): void;
	    release(): void;
	    setTabIndex(index: number | undefined, group: string | undefined): void;
	}

}
declare module 'src/display/Button' {
	import { Label } from 'src/display/Label';
	import { Image } from 'src/display/Image';
	import { InputBase } from 'src/display/private/InputBase';
	/**
	 * 按钮
	 *
	 * @example let button = new vf.gui.Button();
	 *
	 *
	 */
	export class Button extends InputBase {
	    constructor();
	    protected _selectedStr: "AndSelected" | "";
	    protected _oldState: string;
	    private _offsetY;
	    /** 状态展示 */
	    readonly img: Image;
	    /** 文字展示 */
	    readonly label: Label;
	    private _text;
	    /**
	     * 设置按钮的文本内容
	     */
	    get text(): string;
	    set text(value: string);
	    /**
	     *  文本偏移
	     */
	    get textOffsetY(): number;
	    set textOffsetY(value: number);
	    setSelected(value: boolean): void;
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    release(): void;
	    protected onStateChange(label: Button, state: string): void;
	}

}
declare module 'src/display/CheckBox' {
	import { Label } from 'src/display/Label';
	import { Button } from 'src/display/Button';
	/**
	 * 单选\复选框
	 *
	 * 设置checkGroup后，进行分组。 分组后，可理解为复选框。
	 *
	 * @example let checkBox = new vf.gui.CheckBox();
	 *
	 *
	 */
	export class CheckBox extends Button {
	    constructor();
	    /**
	     * 设置值
	     */
	    private _value;
	    /**
	     * 设置是否选中
	     * */
	    private _checked;
	    /**
	     * 获取或设置当前选中的值
	     */
	    get selectedValue(): string | undefined;
	    /**
	     * 设置分组名
	     */
	    get checkGroup(): string | undefined;
	    set checkGroup(value: string | undefined);
	    /**
	     * 获取设置默认值
	     */
	    get value(): string;
	    set value(value: string);
	    /**
	     * 设置是否选中
	     * @default false
	     */
	    get checked(): boolean;
	    set checked(value: boolean);
	    protected onClick(e: any): void;
	    protected onLabelChange(label: Label): void;
	    release(): void;
	}

}
declare module 'src/interaction/InputController' {
	import { DisplayObject } from 'src/core/DisplayObject';
	import { CheckBox } from 'src/display/CheckBox';
	interface CheckGroupObject {
	    groups: {
	        [key: string]: {
	            [value: string]: CheckBox;
	        };
	    };
	    values: {
	        [key: string]: string | undefined;
	    };
	}
	/**
	 *
	 * @private
	 */
	export const tabGroups: {
	    [key: string]: DisplayObject[];
	};
	/**
	 *
	 * @private
	 */
	export const _checkGroupObject: CheckGroupObject;
	/**
	 * 注册组件
	 * @param item
	 * @param tabIndex 切换位置
	 * @param tabGroup 分组名
	 * @returns 依据tabIndex返回是否需要排序 0，-1，1
	 */
	export function registrer(item: DisplayObject, tabIndex: number, tabGroup?: string): void;
	/** 失去焦点时 */
	export function blur(): void;
	/** 设置当前输入组件 */
	export function set(item: DisplayObject): void;
	/** 清楚当前设置的组件 */
	export function clear(): void;
	/** 一般再按下键盘tab健执行 焦点获取与设置 */
	export function fireTab(): void;
	/** 一般再按下键盘向下箭头执行 焦点获取与设置 */
	export function fireNext(): void;
	/** 一般再按下键盘向上箭头执行 焦点获取与设置 */
	export function firePrev(): void;
	/**
	 * 注册分组，一般用于checkBox组件的分组操作
	 *
	 *  ==== 目前没有实现卸载，如果无限制创建checkbox并设置分组可能引发泄露 ====
	 *
	 * checkGroups = [key]:{["value"]:cb}
	 */
	export function registrerCheckGroup(cb: CheckBox): void;
	/**
	 * 注销指定分组或指定分组的子项
	 * @param cb CheckBox
	 */
	export function unRegistrerCheckGroup(cb: CheckBox): void;
	/** 更新分组中选中的checkbox组件  */
	export function updateCheckGroupSelected(cb: CheckBox): void;
	/** 获取分组中选中的checkbox值 */
	export function getCheckGroupSelectedValue(name: string): string | undefined;
	/** 设置选中 */
	export function setCheckGroupSelectedValue(name: string, uuid: string): void;
	export {};

}
declare module 'src/display/Container' {
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 * 基础容器
	 *
	 * 设置checkGroup后，进行分组。 分组后，可理解为复选框。
	 *
	 * @example let container = new vf.gui.Container();
	 *
	 */
	export class Container extends DisplayObject {
	    constructor();
	    /**
	     * 确定指定显示对象是 DisplayObjectContainer 实例的子项或该实例本身。搜索包括整个显示列表（其中包括此 DisplayObjectContainer 实例）。
	     * 孙项、曾孙项等，每项都返回 true。
	     * @param child 要测试的子对象。
	     * @returns 如果 child 对象是 DisplayObjectContainer 的子项或容器本身，则为 true；否则为 false。
	     */
	    contains(child: DisplayObject): boolean;
	}

}
declare module 'src/display/private/GraphicsCore' {
	///   types="@vf.js/vf" />
	/**
	 * 图形逻辑基类
	 */
	export class GraphicsCore extends vf.Graphics {
	    private _lineType;
	    constructor(geometry?: vf.GraphicsGeometry | undefined);
	    private RatioLine;
	    private RatioNone;
	    lineStyle(width?: number, color?: number, alpha?: number, alignment?: number, native?: boolean, lineType?: "full" | "dash"): vf.Graphics;
	    lineTo(x: number, y: number): vf.Graphics;
	    arc(cx: number, cy: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): vf.Graphics;
	    /**
	     * 画椭圆
	    */
	    drawEllipse(xx: number, yy: number, width: number, height: number): vf.Graphics;
	    /**
	     * 圆角矩形
	     */
	    drawRoundedRect(x: number, y: number, width: number, height: number, radius: number): vf.Graphics;
	    /**
	     * 闭合路线
	     */
	    drawPolygonOne(path: vf.Point[], closeStroke?: boolean): vf.Graphics;
	    /**
	     * 判断一个点是否在贝塞尔曲线上
	     * B_{3}(t) = (1 - t)^3P_0 + 3t(1 - t)^2P_1 + 3t^2(1 - t)P_2 + t^3P_3 , t  in[0, 1]
	     *
	     * (x3-3*x2+3*x1-x0)t^3 + (3*x2-6*x1+3*x0)t^2 + (3*x1-3*x0)t + x0
	     *
	     * cpX cpY 控制点一
	     * cpX2 cpY2 控制点二
	     * toX toY 曲线目标点
	     * fromX fromY 曲线起始点
	     * x y 当前点
	     */
	    checOnkBezier(cpX: number, cpY: number, cpX2: number, cpY2: number, toX: number, toY: number, fromX: number, fromY: number, x: number, y: number): number;
	    /**
	     *
	     */
	    quadraticCurveTo(cpX: number, cpY: number, toX: number, toY: number): vf.Graphics;
	    /**
	     * 贝塞尔曲线
	     */
	    bezierCurveTo(cpX: number, cpY: number, cpX2: number, cpY2: number, toX: number, toY: number): vf.Graphics;
	    private drawBezierDash;
	    /**
	    * 获取二阶贝塞尔曲线点信息(近似值 ， n越大值越准确)
	    */
	    quadPointLength(fromX: number, fromY: number, cpX: number, cpY: number, toX: number, toY: number, n?: number): vf.Point[];
	    /**
	     * 获取三阶贝塞尔曲线点信息(近似值 ， n越大值越准确)
	     */
	    bezierPointLength(fromX: number, fromY: number, cpX: number, cpY: number, cpX2: number, cpY2: number, toX: number, toY: number, n?: number): vf.Point[];
	    /**
	     * 根据点取长度
	     */
	    private bezierLength;
	    private bezierToLineData;
	    private pointDistance;
	    /**
	     * 获取线段起始位置或者终止位置角度
	     */
	    getLineRotation(lineTyle: "M" | "L" | "Q" | "C", isBeignPoint: boolean, fromX: number, fromY: number, toX: number, toY: number, cpX?: number, cpY?: number, cpX2?: number, cpY2?: number): number;
	}

}
declare module 'src/display/private/GraphBase' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { MaskSprite } from 'src/core/MaskSprite';
	import { GraphicsCore } from 'src/display/private/GraphicsCore';
	/**
	 * 绘制图形基类
	 */
	export class GraphBase extends DisplayObject implements MaskSprite {
	    constructor();
	    readonly graphics: GraphicsCore;
	    canvas?: HTMLCanvasElement;
	    context?: CanvasRenderingContext2D;
	    texture?: vf.Texture;
	    /** 可以支持遮罩的组件 */
	    maskSprite(): GraphicsCore;
	    /**
	     * 半径
	     */
	    protected _radius: number;
	    get radius(): number;
	    set radius(value: number);
	    /**
	     *
	     */
	    protected _alignment: number;
	    get alignment(): number;
	    set alignment(value: number);
	    /**
	     * 线条样式
	     */
	    protected _lineType: "full" | "dash";
	    get lineType(): "full" | "dash";
	    set lineType(value: "full" | "dash");
	    /**
	     * 线条颜色
	     */
	    protected _lineColor: any;
	    get lineColor(): any;
	    set lineColor(value: any);
	    /**
	     * 线条粗细
	     */
	    protected _lineWidth: number;
	    get lineWidth(): number;
	    set lineWidth(value: number);
	    /**
	     * 线条透明度
	     */
	    protected _lineAlpha: number;
	    get lineAlpha(): number;
	    set lineAlpha(value: number);
	    /**
	     * 填充透明度
	     */
	    protected _fillAlpha: number;
	    get fillAlpha(): number;
	    set fillAlpha(value: number);
	    /**
	     * 颜色
	     */
	    get fillColor(): number[];
	    set fillColor(value: number[]);
	    /**
	     * 颜色
	     */
	    protected _color?: any;
	    get color(): any;
	    set color(value: any);
	    /**
	     * 锚点，调整位图的坐标中点 0-1
	     */
	    get anchorX(): number;
	    set anchorX(value: number);
	    /**
	     * 锚点，调整位图的坐标中点 0-1
	     */
	    get anchorY(): number;
	    set anchorY(value: number);
	    /**
	     * 子类重写
	     */
	    drawGraph(): void;
	    release(): void;
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	}

}
declare module 'src/display/Circle' {
	import { GraphBase } from 'src/display/private/GraphBase';
	/**
	 * 绘制圆形
	 *
	 * 不设置 lineWidth 或 color 圆形不可见
	 *
	 * @example let circle = new vf.gui.Circle();
	 *
	 *
	 */
	export class Circle extends GraphBase {
	    constructor();
	    /**
	     * 开始绘制角度
	     */
	    protected _startAngle: number;
	    get startAngle(): number;
	    set startAngle(value: number);
	    /**
	     * 结束角度
	     */
	    protected _endAngle: number;
	    get endAngle(): number;
	    set endAngle(value: number);
	    /**
	     * 逆时针绘制
	     */
	    protected _anticlockwise: boolean;
	    get anticlockwise(): boolean;
	    set anticlockwise(value: boolean);
	    drawGraph(): void;
	}

}
declare module 'src/display/Star' {
	import { GraphBase } from 'src/display/private/GraphBase';
	export class Star extends GraphBase {
	    constructor();
	    private path;
	    private PI_2;
	    private _triangleNum;
	    private RADIUS_V;
	    private _innerRadius;
	    drawGraph(): void;
	    get triangleNum(): number;
	    set triangleNum(value: number);
	    get innerRadius(): number;
	    set innerRadius(value: number);
	    private setStarPath;
	}

}
declare module 'src/display/Rect' {
	import { GraphBase } from 'src/display/private/GraphBase';
	/**
	 * 绘制矩形或圆角矩形
	 *
	 * 不设置 lineWidth 或 color 矩形不可见
	 *
	 * @example let rect = new vf.gui.Rect();
	 *
	 */
	export class Rect extends GraphBase {
	    constructor();
	    drawGraph(): void;
	}

}
declare module 'src/display/VideoBtn' {
	import { Container } from 'src/display/Container';
	export class VideoBtn extends Container {
	    private _states;
	    private _bgCircle?;
	    private _thumbTriangle?;
	    private _rect1?;
	    private _rect2?;
	    constructor();
	    setStates(states: "play" | "pause"): void;
	    updateDisplayList(): void;
	    private refreshPlay;
	    private refreshPause;
	    private initBgCircle;
	    private onHover;
	    private initTrangle;
	    private initLine;
	    release(): void;
	}

}
declare module 'src/display/Video' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 * 播放器组件
	 *
	 */
	export class Video extends DisplayObject {
	    private _video;
	    private _videoHasEvent;
	    private _src;
	    protected _canvasBounds: {
	        top: number;
	        left: number;
	        width: number;
	        height: number;
	    } | undefined;
	    protected _lastRenderer: vf.Renderer | undefined;
	    protected _resolution: number;
	    private _canplayFun;
	    private _canplaythroughFun;
	    private _completeFun;
	    private _endedFun;
	    private _loadeddataFun;
	    private _durationchangeFun;
	    private _pauseFun;
	    private _playFun;
	    private _autoplay;
	    private _canPlayFirst;
	    private _videoTextrue;
	    private _sprite;
	    private _poster;
	    private _posterImg?;
	    private _videoBtn?;
	    private _firstLoad;
	    private _muted;
	    private _loop;
	    private _controls;
	    private _volume;
	    private _currentTime;
	    private _oldPoster;
	    private _oldSrc;
	    private _canPlay;
	    private _visibleStatus;
	    private _elemDraw;
	    private _isplaying;
	    forceElementDraw: boolean;
	    constructor();
	    private createVideoBtn;
	    private clickAudio;
	    /**
	     *  目前 设置src才会添加sprite到舞台
	     *  创建sprite需要根据src获取纹理
	     */
	    private createVideoSource;
	    private canplayFun;
	    private canplaythroughFun;
	    private completeFun;
	    private pauseFun;
	    private playFun;
	    private endedFun;
	    private loadeddataFun;
	    private checkComatibility;
	    private durationchangeFun;
	    private checkVideoPlay;
	    get x(): number;
	    set x(value: number);
	    get y(): number;
	    set y(value: number);
	    private setPos;
	    private _getCanvasBounds;
	    private updateSystem;
	    private updatePostion;
	    private _lastPostion;
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    private updataPoster;
	    private clearPoster;
	    /**
	     * 支持的参数们~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	     */
	    private _silent;
	    set silent(value: any);
	    get silent(): any;
	    private _audio;
	    set audio(value: any);
	    get audio(): any;
	    get src(): any;
	    set src(value: any);
	    get srcObject(): any;
	    set srcObject(value: any);
	    get autoplay(): boolean;
	    set autoplay(value: boolean);
	    get loop(): boolean;
	    set loop(value: boolean);
	    get poster(): string;
	    set poster(value: string);
	    get muted(): boolean;
	    set muted(boo: boolean);
	    get controls(): boolean;
	    set controls(boo: boolean);
	    get volume(): number;
	    set volume(value: number);
	    get visible(): boolean;
	    set visible(boo: boolean);
	    get videoElement(): HTMLVideoElement;
	    get currentTime(): number;
	    set currentTime(value: number);
	    /**
	     * 设置分组名
	     */
	    get videoGroup(): string | undefined;
	    set videoGroup(value: string | undefined);
	    /**
	     * 只读的属性们~~~~~~~~~~~~~~~~
	     * */
	    get duration(): number;
	    get isPlaying(): boolean;
	    /**
	    * 支持的方法们~~~··~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	    **/
	    play(): void;
	    pause(): void;
	    private _oldX;
	    private _oldY;
	    private _fullStates;
	    requestFullScreen(): void;
	    private fullScreen;
	    private requestFullScreenDom;
	    exitFullscreen(): void;
	    exitFullscreenDom(): void;
	    private clearSource;
	    private clearVideoBtn;
	    private clearVideoEvent;
	    private clearVideo;
	    private clearSprite;
	    private useNativeAudio;
	    private nativeEmit;
	    release(): void;
	}

}
declare module 'src/interaction/VideoGroupController' {
	import { Video } from 'src/display/Video';
	interface VideoGroupObject {
	    groups: {
	        [key: string]: {
	            [value: string]: Video;
	        };
	    };
	    values: {
	        [key: string]: string | undefined;
	    };
	}
	export const _videoGroupObject: VideoGroupObject;
	export function registrerVideoGroup(cb: Video): void;
	/**
	 * 注销指定分组或指定分组的子项
	 * @param cb video
	 */
	export function unRegistrerVideoGroup(cb: Video): void;
	/** 更新分组中选中的checkbox组件  */
	export function updateVideoGroupStates(cb: Video): void;
	export {};

}
declare module 'src/interaction/MouseScrollEvent' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 * 鼠标滑轮事件
	 *
	 *  可侦听事件(未实现):
	 * ```
	 *  {InteractionEvent}.MouseScroll.xxxxxx.
	 * ```
	 *  可赋值方法:
	 * ```
	 * oonMouseScroll: ((e: WheelEvent,delta: vf.Point) => void) | undefined
	 * ```
	 *
	 * @example 可查看 `Slider` 源码
	 *
	 * @since 1.0.0
	 */
	export class MouseScrollEvent {
	    /**
	     *
	     * @param obj 需要绑定的对象
	     * @param preventDefault 是否组织系统默认的事件触发
	     */
	    constructor(obj: DisplayObject, preventDefault: boolean);
	    id: number;
	    private obj;
	    private preventDefault;
	    private delta;
	    private mouseScrllBind;
	    private isStop;
	    startEvent(): void;
	    private _onMouseScroll;
	    private _onHover;
	    private _onMouseOut;
	    stopEvent(): void;
	    remove(): void;
	    onMouseScroll: ((e: WheelEvent, delta: vf.Point) => void) | undefined;
	}

}
declare module 'src/event/ComponentEvent' {
	/**
	 * 特定属性改变时,通常为了去系统事件区分，UI组件的事件名为大写
	 * 1. CheckBox 的 checked 改变时
	 * 2. Label 的 text 改变时
	 * 3. SpriteAnimated 的 animationName 改变时
	 * 4. Button 文字改变
	 * 5. ScrollingContainer 拖动改变时
	 * 6. Slider 滑动改变后
	 * 7. SpriteAnimated 动画改变后
	 * 8. ConnectLine 连线完成时
	 */
	export const CHANGE = "CHANGE";
	/**
	 * 状态改变中
	 *
	 * slider 滑动时
	 */
	export const CHANGEING = "CHANGEING";
	/**
	 * 状态切换完成时
	 *
	 * 1. SpriteAnimated 每次播放完时，触发(loop = false时)
	 * 2. Image 图片加载完成时
	 * 3. Slider 滑动完成
	 * 4. Timeline  每次播放完时，触发(loop = false时)
	 * 5. FollowLine 完成一次划线
	 */
	export const COMPLETE = "COMPLETE";
	/**
	 * 状态发生改变时
	 */
	export const STATE_CHANGE = "STATE_CHANGE";
	/**
	 * 状态切换完成时
	 *
	 * SpriteAnimated 每次播放完时，，触发(loop = true时)
	 */
	export const LOOP = "LOOP";
	/**
	 * 组件被添加前
	 */
	export const ADD = "add";
	/**
	 * 组件被添加时
	 */
	export const ADDED = "added";
	/**
	 * 组件被移除时
	 */
	export const REMOVEED = "removed";
	/**
	 * 组件大小改变后
	 */
	export const RESIZE = "RESIZE";
	/**
	 * 组件位置移动
	 */
	export const MOVE = "MOVE";
	/**
	 * 组件创建完成后
	 */
	export const CREATION_COMPLETE = "CREATION_COMPLETE";
	/**
	 * 拖拽组件按下
	 */
	export const DRAG_DOWN = "DRAG_DOWN";
	/**
	 * 拖拽组件按下
	 */
	export const DRAG_UP = "DRAG_UP";
	/**
	 * 拖拽组件hover
	 */
	export const DRAG_HOVER = "DRAG_HOVER";
	/**
	 * 拖拽组件mouseover
	 */
	export const DRAG_MOUSEENTER = "DRAG_MOUSEENTER";
	/**
	 * 拖拽组件mouseleave
	 */
	export const DRAG_MOUSELEAVE = "DRAG_MOUSELEAVE";
	/**
	 * 组件拖动开始之前
	 */
	export const DRAG_START_BEFORE = "DRAG_START_BEFORE";
	/**
	 * 组件拖动开始时
	 */
	export const DRAG_START = "DRAG_START";
	/**
	 * 组件拖动结束之前
	 */
	export const DRAG_END_BEFORE = "DRAG_END_BEFORE";
	/**
	 * 组件拖动结束时 （如果绑定接收容器并拖动到接收容器中，不会触发此事件）
	 */
	export const DRAG_END = "DRAG_END";
	/**
	 * 组件拖动中
	 */
	export const DRAG_MOVE = "DRAG_MOVE";
	/**
	 * 组件拖动到接收目标中之前
	 */
	export const DRAG_TARGET_BEFORE = "DRAG_TARGET_BEFORE";
	/**
	 * 组件拖动到接收目标中
	 */
	export const DRAG_TARGET = "DRAG_TARGET";
	/**
	 * 有拖拽物掉落到此容器时触发
	 */
	export const DROP_TARGET = "DROP_TARGET";
	/**
	 * 播放音效 {name,mode}
	 */
	export const PLAY_AUDIO = "PLAY_AUDIO";
	/**
	 * 组件宽度发生变化(目前文本换行需要用到)
	 */
	export const WIDTH_CHANGE = "WIDTH_CHANGE";

}
declare module 'src/interaction/GroupController' {
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 *
	 * @private
	 */
	export const _GroupObject: Map<string, {
	    [key: string]: DisplayObject;
	}>;
	/**
	 * 具有ID属性的组件都会添加到本组
	 * @private
	 */
	export const _idObject: Map<string, DisplayObject>;
	export function getObjectById(id: string): DisplayObject | undefined;
	export function registrerID(ui: DisplayObject): boolean;
	export function unRegistrerID(ui: DisplayObject): void;
	/**
	 * 注册分组，
	 */
	export function registrerGroup(ui: DisplayObject): void;
	/**
	 * 注销指定分组或指定分组的子项
	 */
	export function unRegistrerGroup(ui: DisplayObject): void;
	/** 设置选中 */
	export function getGroup(name?: string): {
	    [key: string]: DisplayObject;
	} | undefined;

}
declare module 'src/interaction/Index' {
	import { ClickEvent } from 'src/interaction/ClickEvent';
	import * as DragDropController from 'src/interaction/DragDropController';
	import { DragEvent } from 'src/interaction/DragEvent';
	import * as InputController from 'src/interaction/InputController';
	import * as VideoGroupController from 'src/interaction/VideoGroupController';
	import { MouseScrollEvent } from 'src/interaction/MouseScrollEvent';
	import { InteractionEvent } from 'src/event/InteractionEvent';
	import { TouchMouseEvent } from 'src/event/TouchMouseEvent';
	import * as ComponentEvent from 'src/event/ComponentEvent';
	import * as GroupController from 'src/interaction/GroupController';
	export { ClickEvent, DragDropController, DragEvent, InputController, MouseScrollEvent, InteractionEvent, TouchMouseEvent, ComponentEvent, GroupController, VideoGroupController };

}
declare module 'src/layout/CSSSSystem' {
	/** ===================== mask  ===================== */
	/** ===================== font  ===================== */
	export function updateFontStyle(target: any, key: string, value: any): void;
	export function color(target: any, key: string, value: any): void;
	export function ColorRGBA(target: any, key: "fillColor" | "lineColor", value: number[] | number[][]): void;
	export function lineWidth(target: any, key: "lineWidth", value: number): void;

}
declare module 'src/enum/TracingEnum' {
	export const enum Operate {
	    Add = 0,
	    Clear = 1,
	    Remove = 2
	}
	export const enum Mode {
	    Check = 0,
	    Teach = 1,
	    Auto = 2,
	    Strict = 3,
	    Fill = 4
	}
	export const enum Result {
	    Uncomplete = 0,
	    Correct = 1,
	    Incorrect = 2,
	    Complete = 3
	}

}
declare module 'src/enum/FontWeight' {
	/** 字体粗细 */
	export const enum FontWeight {
	    'normal' = "normal",
	    'bold' = "bold",
	    'bolder' = "bolder",
	    'lighter' = "lighter",
	    'n100' = 100,
	    'n200' = 200,
	    'n300' = 300,
	    'n400' = 400,
	    'n500' = 500,
	    'n600' = 600,
	    'n700' = 700,
	    'n800' = 800,
	    'n900' = 900
	}

}
declare module 'src/enum/Index' {
	import * as FollowLineEnum from 'src/enum/FollowLineEnum';
	import * as TracingEnum from 'src/enum/TracingEnum';
	export { FontWeight } from 'src/enum/FontWeight';
	export { FollowLineEnum, TracingEnum };

}
declare module 'src/layout/CSSStyle' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { FontWeight } from 'src/enum/Index';
	/**
	 * 	定位方式
	 *
	 *  元素的位置通过 "left", "top", "right" 以及 "bottom" 属性进行规定。
	 *
	 * 	absolute 生成绝对定位的元素，相对于第一个父元素进行定位。
	 *
	 *  fixed 生成绝对定位的元素，相对于舞台进行定位。
	 *
	 *  static 没有定位，元素出现在正常的流中（忽略 top, bottom, left, right 或者 z-index 声明）。
	 */
	export type Position = "absolute" | "fixed" | "static";
	/** 对齐方式 父级如果是grid布局，会忽略当前居中模式 */
	export type Align = "flex-start" | "flex-end" | "center";
	/** 布局模式 */
	export type Display = "none" | "block" | "grid";
	/**
	 * 组件样式表
	 */
	export class CSSStyle {
	    constructor(target: DisplayObject);
	    parent: DisplayObject;
	    release(): void;
	    /**
	     * 规定元素的显示类型。布局模式
	     *
	     * grid 模式下，子节点会忽略left,top,right，bottom,width,height等
	     *
	     * none 模式下，忽略style
	     * */
	    private _display;
	    get display(): Display;
	    set display(value: Display);
	    /**
	     * 规定元素的定位类型。
	     * */
	    private _position;
	    get position(): Position;
	    set position(value: Position);
	    /**
	     * 在容器里面的水平位置（左中右）
	     */
	    private _justifyContent?;
	    get justifyContent(): "center" | "flex-start" | "flex-end" | undefined;
	    set justifyContent(value: "center" | "flex-start" | "flex-end" | undefined);
	    /**
	     * 在容器里面的垂直位置（上中下）
	     */
	    private _alignContent?;
	    get alignContent(): "center" | "flex-start" | "flex-end" | undefined;
	    set alignContent(value: "center" | "flex-start" | "flex-end" | undefined);
	    /**
	     * 基于 网格列的维度，去定义网格线的名称和网格轨道的尺寸大小。
	     *
	     * 方式一 [80,90,100]|["30%","40%","30%"] 第一列宽度80，第二列宽度，第三列宽度100
	     *
	     * 方式二 ["repeat",3,100] 三列，宽度都为100像素
	     */
	    private _gridTemplateColumns?;
	    get gridTemplateColumns(): number[] | string[] | [string, number, number] | undefined;
	    set gridTemplateColumns(value: number[] | string[] | [string, number, number] | undefined);
	    /**
	     * 设置列间距
	     */
	    private _gridColumnGap?;
	    get gridColumnGap(): number | undefined;
	    set gridColumnGap(value: number | undefined);
	    /**
	     * 基于 网格行的维度，去定义网格线的名称和网格轨道的尺寸大小。
	     *
	     * 方式一 [80,90,100]|["30%","40%","30%"] 第一行高度80，第二行高度90，第三行行高度100
	     *
	     * 方式二 ["repeat",3,100] 三行，宽度都为100像素
	     */
	    private _gridTemplateRows?;
	    get gridTemplateRows(): number[] | string[] | [string, number, number] | undefined;
	    set gridTemplateRows(value: number[] | string[] | [string, number, number] | undefined);
	    /**
	     * 设置行间距
	     */
	    private _gridRowGap?;
	    get gridRowGap(): number | undefined;
	    set gridRowGap(value: number | undefined);
	    /**
	     * 表示显示对象的宽度，以像素为单位。
	     * */
	    get width(): number | string;
	    set width(value: number | string);
	    /**
	     * 表示显示对象的高度，以像素为单位。
	     * */
	    get height(): number | string;
	    set height(value: number | string);
	    /**
	     * 设置元素的最小宽度。
	     */
	    get minWidth(): number;
	    set minWidth(value: number);
	    /**
	     * 设置元素的最大宽度。
	     */
	    get maxWidth(): number;
	    set maxWidth(value: number);
	    /**
	     * 设置元素的最小高度。
	     */
	    get maxHeight(): number;
	    set maxHeight(value: number);
	    /**
	     * 设置元素的最大高度。
	     * */
	    get minHeight(): number;
	    set minHeight(value: number);
	    /**
	     * 设置定位元素左外边距边界与其容器左边界之间的偏移。
	     * */
	    get left(): any;
	    set left(value: any);
	    /**
	     * 设置定位元素的上外边距边界与其容器上边界之间的偏移。
	     * */
	    get top(): any;
	    set top(value: any);
	    /**
	     * 设置定位元素右外边距边界与其容器右边界之间的偏移。
	     * */
	    get right(): any;
	    set right(value: any);
	    /**
	     * 设置定位元素下外边距边界与其容器下边界之间的偏移。
	     * */
	    get bottom(): any;
	    set bottom(value: any);
	    /**
	     * 缩放
	     * */
	    get scaleX(): number;
	    set scaleX(value: number);
	    /**
	     * 缩放
	     * */
	    get scaleY(): number;
	    set scaleY(value: number);
	    /**
	     * 设置元素水平拉伸扭曲（角度）。
	     * */
	    get skewX(): number;
	    set skewX(value: number);
	    /**
	     * 设置元素垂直拉伸扭曲（角度）。
	     * */
	    get skewY(): number;
	    set skewY(value: number);
	    /**
	     * 设置元素旋转 （角度）
	    */
	    get rotate(): number;
	    set rotate(value: number);
	    /**
	     * 设置元素旋转 （角度）
	    */
	    get rotation(): number;
	    set rotation(value: number);
	    /**
	     * 轴点 像素值
	     */
	    get pivotX(): number;
	    set pivotX(value: number);
	    /**
	     * 轴点 像素值
	     */
	    get pivotY(): number;
	    set pivotY(value: number);
	    /**
	      * 调整元素的色调，取消设置0xFFFFFF
	      */
	    get tint(): number;
	    set tint(value: number);
	    /**
	     * 表示指定对象的 Alpha 透明度值。有效值为0（完全透明）～ 1（完全不透明）。
	     * */
	    get alpha(): number;
	    set alpha(value: number);
	    /**
	     * 显示对象是否可见
	     * */
	    get visible(): boolean;
	    set visible(value: boolean);
	    get visibility(): "visible" | "hidden";
	    set visibility(value: "visible" | "hidden");
	    /**
	     * 设置元件的背景颜色。（16进制数字0xffffff
	     * */
	    get backgroundColor(): number | number[] | number[][] | undefined;
	    set backgroundColor(value: number | number[] | number[][] | undefined);
	    /**
	     * 设置元素的背景圆角
	     */
	    get backgroundRadius(): number;
	    set backgroundRadius(value: number);
	    /**
	     * 设置元素的背景图像。backgroundImage = "./xxx.png"
	     * */
	    get backgroundImage(): string | undefined;
	    set backgroundImage(value: string | undefined);
	    /**
	     * 设置 backgroundImage 后 ，设置背景图像的X位置
	     * */
	    get backgroundPositionX(): number;
	    set backgroundPositionX(value: number);
	    /**
	     * 设置 backgroundImage 后 ，设置背景图像的Y位置
	     * */
	    get backgroundPositionY(): number;
	    set backgroundPositionY(value: number);
	    /**
	     * 设置 backgroundImage 后， 规定背景图像的尺寸。 [width,height]
	     * */
	    get backgroundSize(): number[] | undefined;
	    set backgroundSize(value: number[] | undefined);
	    /**
	     * 设置 backgroundImage 后，设置是否及如何重复背景图像。
	     * repeat重复
	     * no-repeat不重复，
	     */
	    get backgroundRepeat(): "repeat" | "no-repeat";
	    set backgroundRepeat(value: "repeat" | "no-repeat");
	    /**
	     * 设置背景透明度
	     */
	    get backgroundAlpha(): number;
	    set backgroundAlpha(value: number);
	    /**
	     * 遮罩图
	     */
	    get maskImage(): string | vf.Graphics | import("../core/MaskSprite").MaskSprite | undefined;
	    set maskImage(value: string | vf.Graphics | import("../core/MaskSprite").MaskSprite | undefined);
	    /**
	     * 设置位数 [x,y]
	     */
	    get maskPosition(): number[] | undefined;
	    set maskPosition(value: number[] | undefined);
	    /**
	     * 设置遮罩位图的大小
	     */
	    get maskSize(): number[] | undefined;
	    set maskSize(value: number[] | undefined);
	    /**
	     * 设置滤镜
	     */
	    get filter(): any;
	    set filter(value: any);
	    /**
	     * 设置鼠标样式
	     */
	    get cursor(): string;
	    set cursor(value: string);
	    /**
	     * 填充颜色，后面取代Color
	     * 数组形式 [r,g,b,a]
	     */
	    private _fillColor;
	    get fillColor(): number[] | number[][];
	    set fillColor(value: number[] | number[][]);
	    /**
	     * 支持：图形
	     * 边框线条颜色
	     * 数组形式 [r,g,b,a]
	     */
	    private _lineColor;
	    get lineColor(): number[];
	    set lineColor(value: number[]);
	    /**
	     * 支持：图形
	     * 边框线条宽度
	     */
	    private _lineWidth;
	    get lineWidth(): number;
	    set lineWidth(value: number);
	    /**
	     * 文本颜色
	     * 16进制RGB 0xffffff ｜ 16777215
	     * 数组形式 [r,g,b,a]
	     *
	     * 默认白色
	     * */
	    private _color?;
	    get color(): string | number | number[] | string[] | undefined;
	    set color(value: string | number | number[] | string[] | undefined);
	    /** 字符间距 */
	    private _letterSpacing?;
	    get letterSpacing(): number | undefined;
	    set letterSpacing(value: number | undefined);
	    /**
	     * 是否自动换行
	     * */
	    private _wordWrap;
	    get wordWrap(): boolean;
	    set wordWrap(value: boolean);
	    /**
	     * 自动换行的宽度
	     * */
	    private _wordWrapWidth?;
	    get wordWrapWidth(): any;
	    set wordWrapWidth(value: any);
	    /**
	     * 下划线类型
	     * */
	    private _textDecoration;
	    get textDecoration(): "None" | "Overline" | "LineThrough" | "UnderLine";
	    set textDecoration(value: "None" | "Overline" | "LineThrough" | "UnderLine");
	    /**
	    * 下划线颜色
	    * */
	    private _textDecorationColor;
	    get textDecorationColor(): number;
	    set textDecorationColor(value: number);
	    /**
	     * 多行文本(wordWrap = true) - 对齐方式
	     * */
	    private _textAlign;
	    get textAlign(): "left" | "right" | "center";
	    set textAlign(value: "left" | "right" | "center");
	    /**
	     * 多行文本(wordWrap = true) - 垂直对齐方式
	     * */
	    private _verticalAlign;
	    get verticalAlign(): "top" | "bottom" | "middle";
	    set verticalAlign(value: "top" | "bottom" | "middle");
	    /**
	     * 多行文本(wordWrap = true) - 行高
	     * */
	    private _lineHeight?;
	    get lineHeight(): number | undefined;
	    set lineHeight(value: number | undefined);
	    /** 字体 示例：fontFamily = "\"Comic Sans MS\", cursive, sans-serif" */
	    private _fontFamily?;
	    private _whiteFamily;
	    get fontFamily(): string | string[] | undefined;
	    set fontFamily(value: string | string[] | undefined);
	    /** 字体大小 */
	    private _fontSize;
	    get fontSize(): number;
	    set fontSize(value: number);
	    /** 字体样式 */
	    private _fontStyle;
	    get fontStyle(): "normal" | "italic" | "oblique";
	    set fontStyle(value: "normal" | "italic" | "oblique");
	    /**  字体变形，普通或小写  */
	    private _fontVariant;
	    get fontVariant(): "normal" | "small-caps";
	    set fontVariant(value: "normal" | "small-caps");
	    private _fontWeight;
	    /**
	     * 字体粗细
	     * 枚举 vf.gui.enum.FontWeight
	     * */
	    get fontWeight(): FontWeight;
	    set fontWeight(value: FontWeight);
	    /** 内部填充,只支持文字 */
	    private _padding?;
	    get padding(): number | undefined;
	    set padding(value: number | undefined);
	    /** 描边颜色 */
	    private _stroke?;
	    get stroke(): string | number | number[] | undefined;
	    set stroke(value: string | number | number[] | undefined);
	    /** 描边的笔触粗细值 */
	    private _strokeThickness;
	    get strokeThickness(): number;
	    set strokeThickness(value: number);
	    /** 是否设置投影 */
	    private _dropShadow;
	    get dropShadow(): boolean;
	    set dropShadow(value: boolean);
	    /** 投影的alpha值 */
	    private _dropShadowAlpha;
	    get dropShadowAlpha(): boolean;
	    set dropShadowAlpha(value: boolean);
	    /** 是否设置投影 */
	    private _dropShadowAngle;
	    get dropShadowAngle(): number;
	    set dropShadowAngle(value: number);
	    /** 投影的模糊半径 */
	    private _dropShadowBlur;
	    get dropShadowBlur(): number;
	    set dropShadowBlur(value: number);
	    /** 投影填充颜色值 */
	    private _dropShadowColor;
	    get dropShadowColor(): string | number | number[] | undefined;
	    set dropShadowColor(value: string | number | number[] | undefined);
	    /** 投影深度 */
	    private _dropShadowDistance;
	    get dropShadowDistance(): number;
	    set dropShadowDistance(value: number);
	    /**
	     * 渐变类型
	     *  0 = 垂直渐变
	     *  1 = 水平渐变
	     */
	    private _fillGradientType;
	    get fillGradientType(): 0 | 1;
	    set fillGradientType(value: 0 | 1);
	    /** 渐变区间 */
	    private _fillGradientStops;
	    get fillGradientStops(): number[];
	    set fillGradientStops(value: number[]);
	    /** 中文换行 */
	    private _breakWords;
	    get breakWords(): boolean;
	    set breakWords(value: boolean);
	}

}
declare module 'src/layout/CSSBasicLayout' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	export const $tempRectangle: vf.Rectangle;
	/**
	 * 布局尺寸>外部显式设置尺寸>测量尺寸 的优先级顺序返回尺寸
	 */
	export function formatRelative(value: number | string | undefined, total: number): number;
	/**
	 * @private
	 * 一个工具方法，使用BasicLayout规则布局目标对象。
	 */
	export function updateBasicDisplayList(target: DisplayObject | undefined, unscaledWidth: number, unscaledHeight: number): void;

}
declare module 'src/layout/CSSGridLayout' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 *  更新网格布局
	 *
	 * 单位目前只支持数值或百分比：100 ，”100%“
	 *
	 *  网格布局中，子容器的位置与宽高可能失效
	 *
	 * 关于grid布局的词汇表
	 *
	 * 格网 https://developer.mozilla.org/zh-CN/docs/Glossary/Grid
	 *
	 * 网格行 gridTemplateRows https://developer.mozilla.org/zh-CN/docs/Web/CSS/grid-template-columns
	 *
	 * 网格列 gridTemplateColumns https://developer.mozilla.org/zh-CN/docs/Web/CSS/grid-template-rows
	 *
	 * 网格行间距 gridRowGap   https://developer.mozilla.org/zh-CN/docs/Web/CSS/grid-row-gap
	 *
	 * 网格列间距 gridColumnGap  https://developer.mozilla.org/zh-CN/docs/Web/CSS/grid-column-gap
	 *
	 * 网格轴 （未实现） 支持居中方式为：justifyContent，alignContent
	 *
	 * 网格线（未实现） https://developer.mozilla.org/en-US/docs/Glossary/Grid_Lines
	 *
	 * 网格面积（未实现）https://developer.mozilla.org/zh-CN/docs/Glossary/Grid_Areas
	 */
	export function updateGridLayout(target: DisplayObject): vf.Rectangle;

}
declare module 'src/layout/CSSLayout' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { DisplayLayoutAbstract } from 'src/core/DisplayLayoutAbstract';
	export const $TempyAlignRectangle: vf.Rectangle;
	export const $TempLayoutRectangle: vf.Rectangle;
	export const $TempMeasureRectangle: vf.Rectangle;
	/**
	 * @private
	 * 一个工具方法，使用BasicLayout规则测量目标对象。
	 */
	export function measure(target: DisplayLayoutAbstract): void;
	/**
	 * 调整目标的元素的大小并定位这些元素。
	 */
	export function updateDisplayLayout(target: DisplayObject, unscaledWidth: number, unscaledHeight: number): void;

}
declare module 'src/core/plugs/UIBaseDrag' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { InteractionEvent } from 'src/interaction/Index';
	import { DisplayObjectAbstract } from 'src/core/DisplayObjectAbstract';
	import { Stage } from 'src/core/Stage';
	/**
	 *  组件的拖拽操作
	 *
	 */
	export class UIBaseDrag implements Lifecycle {
	    /**
	     * 构造函数
	     */
	    constructor(target: DisplayObject);
	    static key: string;
	    private target;
	    $targetParent: DisplayObject | Stage | undefined;
	    private oldInteractiveChildren;
	    /**
	     * 可拖动初始化
	     *  @default
	     */
	    private dragInitialized;
	    /**
	     * 可被掉落初始化
	     * @default
	    */
	    private dropInitialized;
	    /**
	     * 拖动控制类
	     */
	    private drag;
	    /**
	     * 临时属性，为了解决同步时的动作补齐
	     * 0 没有操作
	     * 1 开始拖动
	     * 2 拖动中
	     * 3 拖动结束
	     * 4 拖动到目标
	     */
	    private _dragState;
	    /**
	     * 位置
	     *
	     */
	    private _dragPosition;
	    /**
	     * 掉落容器的位置
	     */
	    private _dropPosition;
	    /**
	     * 开始的偏移量
	     */
	    private _startOffset;
	    /**
	     * 是否拖动中
	     * @default
	     */
	    dragging: boolean;
	    /**
	     * 当前拖动组件的事件ID，用于处理DragDropController中多组件的选定
	     */
	    get dragDropEventId(): number | undefined;
	    /**
	     * 是否开启拖动
	     * @default false
	     */
	    set draggable(value: boolean);
	    /**
	     * 是否碰撞检测
	     */
	    collision: boolean;
	    /**
	     * 是否设置边界
	     * @default false
	     */
	    dragBoundary: boolean;
	    /**
	     * 是否启用回弹，在移动到非接收方时，回弹到原始位置
	     */
	    dragBounces: boolean;
	    /**
	     * 拖拽时的鼠标状态
	     */
	    dragMoveCursor: string;
	    /**
	     * 限制拖动抽,XY,X抽或Y抽
	     */
	    private _dragRestrictAxis?;
	    get dragRestrictAxis(): "x" | "y" | undefined;
	    set dragRestrictAxis(value: "x" | "y" | undefined);
	    /**
	     * 拖动分组
	     */
	    get dragGroup(): string;
	    set dragGroup(value: string);
	    /**
	     * 拖动时，物体临时的存放容器，设置后，请注意事件流
	     */
	    private _dragContainer;
	    get dragContainer(): DisplayObjectAbstract | undefined;
	    set dragContainer(value: DisplayObjectAbstract | undefined);
	    /**
	     * 是否开启拖动掉落接收
	     */
	    set droppable(value: boolean | undefined);
	    /**
	     * 接收掉落的新容器
	     */
	    private _droppableReparent;
	    get droppableReparent(): DisplayObject | undefined;
	    set droppableReparent(value: DisplayObject | undefined);
	    /**
	     * 接收拖动掉落的分组名
	     */
	    private _dropGroup;
	    set dropGroup(value: string);
	    get dropGroup(): string;
	    protected clearDraggable(): void;
	    private oldWorldTransform;
	    private oldLocalTransform;
	    protected initDraggable(): void;
	    protected checkCollision(e: InteractionEvent): void;
	    protected checkBump(origin: vf.Rectangle, target: vf.Rectangle): boolean;
	    protected clearDroppable(): void;
	    protected initDroppable(): void;
	    onDrop(e: InteractionEvent): void;
	    /**
	     * 同步数据临时的方法
	     */
	    private executeDrop;
	    load(): void;
	    release(): void;
	}

}
declare module 'src/core/plugs/UIClick' {
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 *  组件的单击操作
	 *
	 */
	export class UIClick implements Lifecycle {
	    /**
	     * 构造函数
	     */
	    constructor(target: DisplayObject);
	    static key: string;
	    private _target;
	    private _clickEvent;
	    set double(value: boolean);
	    get double(): boolean;
	    load(): void;
	    release(): void;
	}

}
declare module 'src/core/plugs/HitArea' {
	import { DisplayObject } from 'src/core/DisplayObject';
	export class HitArea implements Lifecycle {
	    private _type;
	    private _x;
	    private _y;
	    private _width;
	    private _height;
	    private _sprite;
	    private _displayObj;
	    private _drawShape?;
	    /**
	     * 构造函数
	     */
	    constructor(target: DisplayObject);
	    static key: string;
	    get type(): "rect" | "ellipse";
	    set type(value: "rect" | "ellipse");
	    get x(): number;
	    set x(value: number);
	    get y(): number;
	    set y(value: number);
	    get width(): number;
	    set width(value: number);
	    get height(): number;
	    set height(value: number);
	    updataHitArea(): void;
	    private getHitArea;
	    load(): void;
	    release(): void;
	}

}
declare module 'src/core/DisplayObject' {
	///   types="@vf.js/vf" />
	import { DisplayLayoutAbstract } from 'src/core/DisplayLayoutAbstract';
	import { CSSStyle } from 'src/layout/CSSStyle';
	import { UIBaseDrag } from 'src/core/plugs/UIBaseDrag';
	import { HitArea } from 'src/core/plugs/HitArea';
	/**
	 * UI的顶级类，基础的UI对象
	 *
	 * @class
	 * @since 1.0.0
	 */
	export class DisplayObject extends DisplayLayoutAbstract implements Lifecycle {
	    /**
	     * 构造函数
	     */
	    constructor();
	    /**
	     * 插件列表
	     */
	    plugs: Map<string, Lifecycle>;
	    /**
	     * 拖动限制门槛,小于设置的数不执行拖动,防止点击与滚动
	     */
	    dragThreshold: number;
	    /** 拖动时，事件流是否继续传输 */
	    dragStopPropagation: boolean;
	    /** 模糊 */
	    private blurFilter?;
	    /** 子类实现 */
	    _anchorX: number;
	    /** 子类实现 */
	    _anchorY: number;
	    /**
	     * 设置拖动
	     */
	    get dragOption(): UIBaseDrag;
	    set dragOption(value: UIBaseDrag);
	    /** 是否开启鼠标或触摸点击，开启后，接收TouchMouseEvent */
	    get interactabled(): boolean;
	    set interactabled(value: boolean);
	    /**
	     * 设置拖拽
	     */
	    get hitArea(): HitArea;
	    checkHitArea(): boolean;
	    /** 是否开启鼠标或触摸点击，开启后，接收TouchMouseEvent */
	    get isClick(): boolean;
	    set isClick(value: boolean);
	    /**
	     * 分组
	     */
	    protected _groupName?: string;
	    get groupName(): string | undefined;
	    set groupName(value: string | undefined);
	    /**
	     * 透明度
	     */
	    get alpha(): number;
	    set alpha(value: number);
	    /**
	     * 色调
	     * @default 0xFFFFFF
	     * */
	    protected _tint: number;
	    get tint(): number;
	    set tint(value: number);
	    /**
	     * 混合模式
	     */
	    private _blendMode;
	    get blendMode(): vf.BLEND_MODES | undefined;
	    set blendMode(value: vf.BLEND_MODES | undefined);
	    private _filterProxy;
	    private _filterMap;
	    private _filterCount;
	    get filter(): any;
	    /**
	     * 设置Blur XY的模糊强度
	     *
	     * 参数类型为number时，设置 blurX = blurY = value
	     *
	     */
	    set filterBlur(value: number);
	    get filterBlur(): number;
	    /**
	     * 设置灰度
	     *
	     * 参数类型为 number, 接收一个百分比值，然后再将其转换为小数
	     */
	    private grayscaleFilter?;
	    private grayscaleFilterValue;
	    set filterGrayscale(value: number);
	    get filterGrayscale(): number;
	    /**
	     * 私有样式代理
	     * */
	    protected _style?: CSSStyle;
	    /**
	    *  在不同分辨率下保持像素稳定
	    * @default
	    */
	    pixelPerfect: boolean;
	    /**
	     * 动态属性，避免其他类注入
	     */
	    attach: {
	        [key: string]: object | number | string | Function;
	    };
	    /**
	     * 获取样式
	     */
	    get style(): CSSStyle;
	    set style(value: CSSStyle);
	    toDomRectangle(): vf.Rectangle;
	    /**
	     * 更新显示列表,子类重写，实现布局
	     */
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    load(): void;
	    release(): void;
	    releaseAll(): void;
	}

}
declare module 'src/utils/GraphicsUtils' {
	export function parseValues(args: any): any;
	export function vectorAngle(ux: any, uy: any, vx: any, vy: any): number;
	export function getArcCenter(px: number, py: number, cx: number, cy: number, rx: number, ry: number, largeArcFlag: number, sweepFlag: number, sinphi: number, cosphi: number, pxp: number, pyp: number): number[];
	export function approxUnitArc(ang1: number, ang2: number): {
	    x: number;
	    y: number;
	}[];
	export function mapToEllipse(data: {
	    x: number;
	    y: number;
	}, rx: number, ry: number, cosphi: number, sinphi: number, centerx: number, centery: number): {
	    x: number;
	    y: number;
	};
	export function arcToBezier(px: number, py: number, cx: number, cy: number, rx: number, ry: number, xAxisRotation?: number, largeArcFlag?: number, sweepFlag?: number): {
	    x1: number;
	    y1: number;
	    x2: number;
	    y2: number;
	    x: number;
	    y: number;
	}[];
	/**
	 * svg格式拆数组格式
	 * cmds
	(4) [Array(3), Array(8), Array(8), Array(1)]
	0: (3) ["M", 280, 250]
	1: (8) ["A", 200, 200, 0, 1, 1, 680, 250]
	2: (8) ["A", 200, 200, 0, 1, 1, 280, 250]
	3: ["Z"]
	length: 4
	 */
	export function parser(path: any): any;
	export function q2b(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): number[];
	/**
	 * 解析svg的path
	 *
	 *
	    M = moveto
	    L = lineto
	    H = horizontal lineto
	    V = vertical lineto
	    C = curveto
	    S = smooth curveto
	    Q = quadratic Belzier curve
	    T = smooth quadratic Belzier curveto
	    A = elliptical Arc
	    Z = closepath
	    以上所有命令均允许小写字母。大写表示绝对定位，小写表示相对定位(从上一个点开始)。
	 */
	export function parseSvgData(path: string): never[][];
	export function toSVGString(shapes: any): any;

}
declare module 'src/utils/ObjectPool' {
	 class ObjectPool {
	    constructor();
	    /**
	     * 作为对象池的词典dict
	     */
	    private objPoolDict;
	    /**
	     * 向对象池中放入对象，以便重复利用
	     */
	    push<T extends Lifecycle, S>(keyClass: S, oldObj: T): void;
	    /**
	     * 从对象池中取出需要的对象
	     * @return 取出的相应对象
	     *
	     */
	    pop<T>(keyClass: T): any;
	}
	/**
	 * 对象池实例
	 */
	export const objectPoolShared: ObjectPool;
	export {};

}
declare module 'src/utils/calculateUpdatePlayerSize' {
	///   types="@vf.js/vf" />
	import { Stage } from 'src/core/Stage';
	export const enum ScaleMode {
	    SHOW_ALL = "showAll",
	    NO_SCALE = "noScale",
	    COVER = "cover",
	    CONTAIN = "contain",
	    FIXEDHEIGHT = "fixedHeight",
	    FIXEDWIDTH = "fixedWidth"
	}
	export function getBoundingClientRect(dom: HTMLElement): DOMRect;
	/**
	 * @private
	 *
	 * 更新播放器视口尺寸
	 *
	 * noScale 不对内容进行任何缩放，保持原始的1:1比例。如果播放器窗口比内容小，则可能进行一些裁切。
	 *
	 * showAll 非溢出居中，显示全部内容。水平或垂直“两侧”可能会不够宽而留有黑边。
	 *
	 * contain 非溢出，显示全部内容，水平或垂直“一侧”方向有黑边。
	 *
	 * cover 溢出居中，某些部分也许无法显示在播放器视口。
	 */
	export function calculateUpdatePlayerSize(scrennDiv: HTMLElement, app: vf.Application, stage: Stage, stageW: number, stageH: number, scaleMode: ScaleMode): {
	    width: number;
	    height: number;
	    scaleX: number;
	    scaleY: number;
	};

}
declare module 'src/utils/setInteractiveElement' {
	/**
	 * 设置事件绑定目标
	 * @param stage
	 * @param parame
	 */
	export function setInteractiveElement(stage: vf.gui.Stage, parame: {
	    className: string;
	    defaultPointer: string;
	    htmlElement?: HTMLElement;
	    resolution?: number;
	}): void;

}
declare module 'src/utils/cacheDestroy' {
	export function cacheDestroy(res: any, bool: boolean): void;

}
declare module 'src/utils/Utils' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { Stage } from 'src/core/Stage';
	import { DisplayObjectAbstract } from 'src/core/DisplayObjectAbstract';
	export * from 'src/utils/ObjectPool';
	export * from 'src/utils/calculateUpdatePlayerSize';
	export * from 'src/utils/setInteractiveElement';
	export * from 'src/utils/cacheDestroy';
	/**
	 * 是否调试模式
	 */
	export let debug: boolean;
	/**
	 * 工具类
	 */
	/** 日志输出 */
	export function log(message?: string | number | object, ...optionalParams: string[] | number[] | object[]): void;
	/**
	 * 组件获取资源 - 源路径,外部可以重写本方法
	 */
	export let $getSourcePath: Function;
	export function setSourcePath(params: (path: any, cls?: any) => {}): void;
	/**
	 * 根据显示路径，获取显示对象
	 */
	export let $getUIDisplayObjectPath: Function;
	export function setDisplayObjectPath(params: (cls?: any, target?: DisplayObject) => {}): void;
	export function getSource(src: any): any;
	export function getTexture(src: any): any;
	export function getSheet(src: any): any;
	export function getSound(src: any): any;
	export function getDisplayObject(src: any, target?: DisplayObject): any;
	/**
	 * 递归获取舞台，组件必须已经添加到舞台
	 * @param DisplayObject
	 */
	export function getStage(target: DisplayObject | DisplayObjectAbstract | Stage): Stage | undefined;
	/**
	 * 获取显示对象的路径(解析json需要的id，并不是uuid)
	 * @param target
	 * @param ids
	 */
	export function getDisplayPathById(target: DisplayObject | DisplayObjectAbstract | Stage, ids?: string[]): string[];
	/**
	 * 快速设置矩形
	 * @param sourcr
	 * @param x
	 * @param y
	 * @param w
	 * @param h
	 */
	export function setRectangle(source: vf.Rectangle, x: number, y: number, w: number, h: number): void;
	/** 获取当前运行时时间 */
	export function now(): number;
	/**
	 * 深度拷贝对象
	 * @param source 对象元
	 */
	export function deepCopy(source: any, target?: any): any;
	/**
	 * helper function to convert string hex to int or default
	 *
	 * 16进制转int，颜色转换
	 * @param str 要转换的值，如#FFFFFF,0xFFFFFF
	 * @param def 转换失败的返回值
	 */
	export function hexToInt(str?: string | number, def?: any): any;
	/**
	 * helper function to convert string hex to int or default
	 *
	 * 16进制转int，颜色转换
	 * @param str 要转换的值，如#FFFFFF,0xFFFFFF
	 * @param def 转换失败的返回值
	 */
	export function hexListToIntList(str?: string | number | string[] | number[], def?: any): any;
	/**
	 *
	 * @param hex 16进制字符窜 如 #FFFFFF ，不能省略三位写法
	 * @param alpha 透明度
	 * @returns "rgba(255,255,255,1)" || false
	 */
	export function hexToRgba(hex: string, alpha: number): string | false;
	/**
	 * 转换为16位字符串，不够2位的补0，如 “01”
	 * @param c 要转换的数字
	 */
	export function componentToHex(c: number): string;
	/**
	 * RGB转16进制
	 * @param r 红 0-255
	 * @param g 绿 0-255
	 * @param b 蓝 0-255
	 */
	export function rgbToHex(r: number, g: number, b: number): string;
	/**
	 * RGB转number
	 * @param r 红 0-255
	 * @param g 绿 0-255
	 * @param b 蓝 0-255
	 */
	export function rgbToNumber(r: number, g: number, b: number): number;
	/**
	 * rgb字符串形式转换
	 * @param color rgb(255,255,255)
	 */
	export function rgbStrToNumber(color: string): number;
	/**
	 * 10进制转RGB
	 * @param c 数
	 */
	export function numberToRgb(c: number): {
	    r: number;
	    g: number;
	    b: number;
	};
	/**
	 * hex 转 RGB，
	 *
	 * 如hex字符串: "#ffffff"->255,255,255
	 *
	 * 如16进制数字: 0xffffff->255,255,255
	 * @param hex
	 */
	export function hexToRgb(hex?: string | number): {
	    r: number;
	    g: number;
	    b: number;
	};
	/**
	 * 根据amt计算当前的位置start-stop，两数差值
	 * @param start 开始数值
	 * @param stop  结束的数值
	 * @param amt 0-1 用时 >1为1，小于0为0
	 */
	export function Lerp(start: number, stop: number, amt: number): number;
	/**
	 * 四舍五入保留指定位数的小数
	 * @param num 取舍的数
	 * @param decimals 保留小数位
	 */
	export function Round(num: number, decimals: number): number;
	/** 获取全局唯一数 */
	export function uid(): number;
	/** 获取URL参数 */
	export function getQueryVariable(variable: string): string | null | undefined;
	/**
	 * 解析一个字符串函数的参数，如xxx(1) = 1
	 * @param
	 */
	export function getStringFunctionParam(str: string): {
	    key: string;
	    value: number;
	};
	export function isDeltaIdentity(m: vf.Matrix): boolean;
	/**
	 * 格式化一个百分比为小数
	 * @param value
	 * @param total
	 */
	export function formatRelative(value: number | string | undefined, total: number): number;
	/** 计算两点距离 */
	export function pointDistance(pointA: vf.Point | {
	    x: number;
	    y: number;
	}, pointB: vf.Point | {
	    x: number;
	    y: number;
	}): number;
	/** 坐标相减 */
	export function pointSub(source: vf.Point | {
	    x: number;
	    y: number;
	}, subPoint: vf.Point | {
	    x: number;
	    y: number;
	}): {
	    x: number;
	    y: number;
	};
	/** 坐标相加 */
	export function pointPlus(source: vf.Point | {
	    x: number;
	    y: number;
	}, PlusPoint: vf.Point | {
	    x: number;
	    y: number;
	}): {
	    x: number;
	    y: number;
	};
	/** 向量转弧度 */
	export function pointSignAngle(pointA: vf.Point | {
	    x: number;
	    y: number;
	}, pointB: vf.Point | {
	    x: number;
	    y: number;
	}): number;
	/**
	 *  根据类型获得具体的类定义
	 * @param type
	 */
	export function getGuiClass(type: string): any;
	export function sayHello(): void;
	/**
	 * 全局坐标转本地坐标
	 */
	export function toLocal(position: vf.IPoint, localDisplayObject: vf.DisplayObject | DisplayObjectAbstract): vf.Point;
	/**
	 * 本地坐标转全局坐标
	 */
	export function toGlobal(position: vf.IPoint, localDisplayObject: vf.DisplayObject | DisplayObjectAbstract): vf.Point;
	/**
	 * 本地坐标转全局
	 */
	export function toWorldTransform(localDisplayObject: vf.DisplayObject | DisplayObjectAbstract): vf.Matrix;
	export function toLoacalTransform(localDisplayObject: vf.DisplayObject | DisplayObjectAbstract): vf.Matrix;
	/**
	 * 本地显示对象转换到DIV坐标，核心是减去canvas的偏移量
	 * @param localDisplayObject
	 * @returns
	 */
	export function toDomRectangle(localDisplayObject: DisplayObjectAbstract | Stage, point?: vf.IPointData): vf.Rectangle;
	/**
	 * svgData to array
	 */
	export function path2shapes(path: string): never[][];
	/**
	 * array to svgData
	 */
	export function toSVGStr(shapes: any): any;
	export class ParseDataItem {
	    type: "M" | "L" | "Q" | "C";
	    x: number;
	    y: number;
	    ct1X: number;
	    ct1Y: number;
	    ct2X: number;
	    ct2Y: number;
	}
	/**
	 * 创建显示对象
	 * @param moduleName
	 * @param option
	 * @param parent
	 * example:
	 *   let img = vf.gui.Utils.createDisplayObject("Image", {x: 0, y: 0, src: 'xxxx.png'}, this) as vf.gui.Image;
	 */
	export function createDisplayObject(moduleName: string, option: any, parent?: DisplayObjectAbstract): any;

}
declare module 'src/core/Filter' {
	///   types="@vf.js/vf" />
	export class Filter extends vf.Filter {
	    static isFilter: boolean;
	    static defaultFilterVertex: string;
	    static list: Map<string, boolean>;
	    constructor(vertexSrc?: string, fragmentSrc?: string, uniforms?: {
	        [key: string]: any;
	    });
	}

}
declare module 'src/display/Slider' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { Image as VfuiImage } from 'src/display/Image';
	import { DragEvent, InteractionEvent } from 'src/interaction/Index';
	/**
	 * 滑动条/进度条
	 *
	 * @example let slider = new vf.gui.Slider();
	 *
	 */
	export class Slider extends DisplayObject {
	    constructor();
	    /**
	     * 当前值
	     */
	    protected _amt: number;
	    /**
	     * 小数的保留位，0不保留
	     * @default 0
	     */
	    protected _decimals: number;
	    protected _startValue: number;
	    protected _maxPosition: number;
	    protected _lastChange: number;
	    protected _lastChanging: number;
	    protected _localMousePosition: vf.Point;
	    /** 状态展示 */
	    readonly trackImg: VfuiImage;
	    readonly thumbImg: VfuiImage;
	    readonly tracklightImg: VfuiImage;
	    protected _thumbDrag: DragEvent;
	    protected _trackDrag: DragEvent;
	    /**
	     * 当前值
	     */
	    get value(): number;
	    set value(value: number);
	    protected valueSystem(value?: number): void;
	    /**
	     * 最小值
	     */
	    protected _minValue: number;
	    get minValue(): number;
	    set minValue(value: number);
	    /**
	     * 最大值
	     */
	    protected _maxValue: number;
	    get maxValue(): number;
	    set maxValue(value: number);
	    /**
	     * 是否垂直,滑块方向
	     */
	    protected _vertical: boolean;
	    get vertical(): boolean;
	    set vertical(value: boolean);
	    /**
	     * 背景
	     */
	    protected _track?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    get track(): string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined;
	    set track(value: string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined);
	    /**
	     * 手柄
	     */
	    protected _thumb?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    get thumb(): string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined;
	    set thumb(value: string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined);
	    /**
	     * 进度
	     */
	    protected _tracklight?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    get tracklight(): string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined;
	    set tracklight(value: string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined);
	    protected onImgload(): void;
	    protected updatePosition(soft?: boolean): void;
	    protected onPress(event: InteractionEvent, isPressed: boolean, dragEvent?: DragEvent): void;
	    protected onDragStart(event: InteractionEvent): void;
	    protected onDragMove(event: InteractionEvent, offset: vf.Point): void;
	    protected onDragEnd(event: InteractionEvent): void;
	    protected updatePositionToMouse(mousePosition: vf.Point, soft: boolean): void;
	    protected triggerValueChange(): void;
	    protected triggerValueChanging(): void;
	    updateLayout(): void;
	    protected commitProperties(): void;
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    release(): void;
	}

}
declare module 'src/display/ScrollBar' {
	///   types="@vf.js/vf" />
	import { Slider } from 'src/display/Slider';
	import { ScrollingContainer } from 'src/display/ScrollingContainer';
	import { Image } from 'src/display/Image';
	import { InteractionEvent } from 'src/interaction/Index';
	/**
	 * UI 带有滚动条的容器
	 */
	export class ScrollBar extends Slider {
	    constructor();
	    /**
	     * 是的自动隐藏滚动条
	     */
	    autohide: boolean;
	    private _scrollingContainer;
	    private _hidden;
	    protected toggleHidden(hidden: boolean): void;
	    protected onThumbLoadComplete(rectangle: vf.Rectangle, source: Image): void;
	    protected triggerValueChanging(): void;
	    private _source;
	    get source(): ScrollingContainer | string | undefined;
	    set source(value: ScrollingContainer | string | undefined);
	    private _dragScrolling;
	    get dragScrolling(): boolean;
	    set dragScrolling(value: boolean);
	    protected commitProperties(): void;
	    protected alignToContainer(): void;
	    protected onDragMove(event: InteractionEvent, offset: vf.Point): void;
	    protected updatePosition(soft?: boolean): void;
	    release(): void;
	}

}
declare module 'src/display/ScrollingContainer' {
	///   types="@vf.js/vf" />
	import { Container } from 'src/display/Container';
	import { ContainerBase } from 'src/core/ContainerBase';
	import { DisplayObjectAbstract } from 'src/core/DisplayObjectAbstract';
	/**
	 * 可滚动的容器
	 *
	 * @example let scrollingContainer = new vf.gui.ScrollingContainer();
	 *
	 */
	export class ScrollingContainer extends Container {
	    constructor();
	    /**
	     * 是否启动拖拽滚动
	     * @default true
	     */
	    private _dragScrolling;
	    get dragScrolling(): boolean;
	    set dragScrolling(value: boolean);
	    /**
	     * 滚动的阻力或柔度 (0-1)
	     * @default 0.5
	     */
	    softness: number;
	    /**
	     * 滚动条的圆角半径 设置0时，滚动条为直角长方形
	     * @default 0
	     */
	    radius: number;
	    private scrollMask;
	    /**
	     * 遮罩的扩充范围
	     */
	    expandMask: number;
	    /**
	     * 是否开启滚动动画
	     * @default false
	     */
	    animating: boolean;
	    /**
	     * 是否启用水平滚动
	     * @default false
	     */
	    scrollX: boolean;
	    /**
	     * 是否滚动中
	     */
	    scrollY: boolean;
	    /**
	     * 内容容器
	     * @private
	     */
	    private _innerContainer;
	    /**
	     * 内容的宽高
	     */
	    innerBounds: vf.Rectangle;
	    /**
	     * 拖动处理类
	     */
	    private dragEvent?;
	    /**
	     * 鼠标滚动
	     */
	    private mouseScrollEvent?;
	    /**
	     * 是否滚动中
	     */
	    private scrolling;
	    /**
	     * 临时方案，设置时间间隔，跳转容器宽高
	     */
	    private _boundCached;
	    private _lastWidth;
	    private _lastHeight;
	    private _isInitScrolling;
	    private _containerStart;
	    private _targetPosition;
	    private _lastPosition;
	    private _Position;
	    private _Speed;
	    private _stop;
	    private isInitDrag;
	    protected initDrag(): void;
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    protected setScrollPosition(speed?: vf.Point): void;
	    get innerContainer(): ContainerBase;
	    addChild<T extends DisplayObjectAbstract>(item: T): T;
	    addChildAt<T extends DisplayObjectAbstract>(item: T, index: number): T;
	    getInnerBounds(force?: boolean): vf.Rectangle;
	    $onInit(): void;
	    protected initScrolling(): void;
	    protected updateScrollBars(): void;
	    /**
	     * 百分比设置位置
	     * @param direction 方向
	     * @param pct 百分比0-1
	     */
	    forcePctPosition(direction: "x" | "y", pct: number): void;
	    /** 根据焦点设置位置 */
	    focusPosition(pos: vf.Point): void;
	    protected updateScrollPosition(delta: number): void;
	    protected updateDirection(direction: "x" | "y", delta: number): void;
	    release(): void;
	}

}
declare module 'src/display/SpriteAnimated' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 * 序列图动画
	 *
	 * 支持使用texturepacker导出以及处理轴点
	 *
	 * @example let spriteAnimated = new vf.gui.SpriteAnimated();
	 *
	 */
	export class SpriteAnimated extends DisplayObject {
	    constructor();
	    private _animatedSprites;
	    private _lastAnimatedName;
	    private _curFrameNumber;
	    private _setTimeoutId;
	    /**
	     * 要播放的动作名
	     */
	    private _animationName;
	    get animationName(): string;
	    set animationName(value: string);
	    /**
	     * 序列图路径，或序列图数组
	     */
	    private _src;
	    get src(): vf.Spritesheet | vf.Texture[] | vf.AnimatedSprite.FrameObject[] | undefined;
	    set src(value: vf.Spritesheet | vf.Texture[] | vf.AnimatedSprite.FrameObject[] | undefined);
	    /**
	     * 动画速度
	     */
	    private _animationSpeed;
	    get animationSpeed(): number;
	    set animationSpeed(value: number);
	    /**
	     * 是的循环
	     */
	    private _loop;
	    get loop(): boolean;
	    set loop(value: boolean);
	    private _playCount;
	    /**
	     * 循环次数
	     */
	    private _loopCount;
	    get loopCount(): number;
	    set loopCount(value: number);
	    /**
	     * 是否播放中
	     */
	    private _playing;
	    get playing(): boolean;
	    /**
	     * 锚点，调整位图的坐标中点 0-1, 可通过 TexturePacker输出sheet图并设置好 anchor
	     */
	    get anchorX(): number;
	    set anchorX(value: number);
	    /**
	     * 锚点，调整位图的坐标中点 0-1, 可通过 TexturePacker输出sheet图并设置好 anchor
	     */
	    get anchorY(): number;
	    set anchorY(value: number);
	    /** 跳转到第N帧并播放 */
	    gotoAndPlay(frameNumber: number): void;
	    /** 跳转到第N帧并停止 */
	    gotoAndStop(frameNumber: number): void;
	    /** 停止 */
	    stop(): void;
	    /** 播放 */
	    play(): void;
	    /**
	     * 请在构造函数后立即设置
	     */
	    get autoPlay(): boolean;
	    set autoPlay(value: boolean);
	    set isPlay(value: boolean);
	    /**
	     * 添加动画
	     */
	    addAnimated(animationName: string, textures: vf.Texture[] | vf.AnimatedSprite.FrameObject[]): void;
	    release(): void;
	    protected releaseAnimate(): void;
	    protected srcSystem(): void;
	    protected animatedNameSystem(): void;
	    protected playSystem(): void;
	    protected attribSystem(): void;
	}

}
declare module 'src/event/KeyEvent' {
	/**
	 * 键盘事件 驱动类KeysEvent
	 *
	 */
	export const enum KeyEvent {
	    input = "input",
	    /**
	     * 键盘按下
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    keydown = "keydown",
	    /**
	     * 键盘弹起
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    keyup = "keyup",
	    /**
	     * 粘贴
	     *
	     * (e:InteractionEvent,obj:DisplayObject,clipboardData: DataTransfer | null)
	     */
	    paste = "paste",
	    /**
	     * 复制
	     *
	     * (e:InteractionEvent,obj:DisplayObject,clipboardData: DataTransfer | null)
	     */
	    copy = "copy",
	    /**
	     * 剪切
	     *
	     * (e:InteractionEvent,obj:DisplayObject,clipboardData: DataTransfer | null)
	     */
	    cut = "cut",
	    /**
	     * 回退删除
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    backspace = 8,
	    /**
	     * 回车
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    enter = 13,
	    /**
	     * 删除
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    delete = 46,
	    /**
	     * 全选 ctrl+a
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    ctrlA = 65,
	    /**
	     * 撤销 ctrl+z
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    ctrlZ = 90,
	    /**
	     * 箭头左
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    left = 37,
	    /**
	     * 箭头上
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    top = 38,
	    /**
	     * 箭头右
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    right = 39,
	    /**
	     * 箭头下
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    down = 40,
	    /**
	     * shift + 箭头左
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    shiftLeft = "shift37",
	    /**
	     * shift + 箭头右
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    shiftRight = "shift39",
	    /**
	     * shift + 箭头上
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    shiftTop = "shift38",
	    /**
	     * shift + 箭头下
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    shiftDown = "shift40"
	}

}
declare module 'src/display/private/HtmlInput' {
	///   types="@vf.js/vf" />
	/**
	 * 私有的，由于VFJS不支持文本输入，这里以HTML方式实现
	 */
	export default class HtmlInput extends vf.utils.EventEmitter {
	    constructor(multiline: boolean);
	    private _domInput;
	    private _selection;
	    private _restrictRegex;
	    private _restrictValue;
	    get domInput(): HTMLInputElement | HTMLTextAreaElement;
	    set visible(value: boolean);
	    get visible(): boolean;
	    get value(): string;
	    set value(value: string);
	    set placeholder(value: string);
	    set disabled(value: boolean);
	    get maxlength(): number;
	    set maxlength(value: number);
	    get restrict(): RegExp | undefined;
	    set restrict(regex: RegExp | undefined);
	    setStyle(style: InputStyle): void;
	    setStyleValue(key: any, value: any): void;
	    select(): void;
	    /** 测量，需要对象添加到body中 */
	    getDOMInputBounds(): DOMRect;
	    updatePostion(top: string | number, left: string | number, transform: string, opacity?: string | number): void;
	    private addDom;
	    private removeDom;
	    release(): void;
	    private _onInputKeyDownBind;
	    private _onInputInputBind;
	    private _onInputKeyUpBind;
	    private _onFocusedBind;
	    private _onBlurredBind;
	    private addEvent;
	    private removeEvent;
	    private _applyRestriction;
	    private _onInputKeyDown;
	    private _onInputInput;
	    private _onInputKeyUp;
	    private _onFocused;
	    private _onBlurred;
	    focus(): void;
	    blur(): void;
	}

}
declare module 'src/display/TextInput' {
	///   types="@vf.js/vf" />
	import HtmlInput from 'src/display/private/HtmlInput';
	import { InputBase } from 'src/display/private/InputBase';
	import { Image } from 'src/display/Image';
	/**
	 * 文本输入
	 *
	 * @example let textInput = new vf.gui.TextInput(true|false);//单行或多行
	 *
	 */
	export class TextInput extends InputBase {
	    constructor(multiline?: boolean);
	    protected _oldState: string;
	    protected htmlInputShared: HtmlInput;
	    protected _lastRenderer: vf.Renderer | undefined;
	    protected _resolution: number;
	    protected _canvasBounds: {
	        top: number;
	        left: number;
	        width: number;
	        height: number;
	    } | undefined;
	    protected _previous: {
	        canvasBounds: any;
	        worldTransform: any;
	        worldAlpha: any;
	        worldVisible: any;
	    } | any;
	    protected _inputStyle: InputStyle;
	    /**
	     * 预览文字的样式
	     */
	    protected placeholderColor: number;
	    protected _domVisible: boolean;
	    protected _textHitbox: vf.Graphics;
	    protected _textMask: vf.Graphics;
	    protected _text: vf.Text;
	    protected _fontMetrics: vf.IFontMetrics | undefined;
	    protected state: string;
	    /**
	     * 设置文本
	     */
	    get text(): string;
	    set text(value: string);
	    /**
	     * 预览文字
	     */
	    private _placeholder;
	    get placeholder(): string;
	    set placeholder(value: string);
	    /**
	     * 设置最大可输入
	     */
	    private _maxLength;
	    get maxLength(): number;
	    set maxLength(value: number);
	    /**
	     * 过滤表达式
	     */
	    private _restrict;
	    get restrict(): RegExp | undefined;
	    set restrict(value: RegExp | undefined);
	    /**
	     * 状态展示
	    */
	    readonly img: Image;
	    updateSystem(renderer?: vf.Renderer): void;
	    /**
	     * 设置焦点
	     */
	    focus(): void;
	    /**
	     * 失去焦点
	     */
	    blur(): void;
	    /**
	     * 设置css style样式
	     * @param key 健
	     * @param value 值
	     */
	    setInputStyle(key: any, value: any): void;
	    protected onStateChange(ui: TextInput, state: string): void;
	    private _onInputInput;
	    private _onFocused;
	    private _onBlurred;
	    private _setState;
	    private _updateSubstitution;
	    render(renderer: vf.Renderer): void;
	    private _renderInternal;
	    private _updateDOMInput;
	    private _needsUpdate;
	    private _updatetext;
	    private _ontextFocus;
	    private _ensureFocus;
	    private _derivetextStyle;
	    private _derivetextPadding;
	    private _derivetextText;
	    private _hasFocus;
	    private _getCanvasBounds;
	    private _getDOMRelativeWorldTransform;
	    private _vfMatrixToCSS;
	    private _comparevfMatrices;
	    private _compareClientRects;
	    release(): void;
	}

}
declare module 'src/display/Polygon' {
	import { GraphBase } from 'src/display/private/GraphBase';
	export class Polygon extends GraphBase {
	    constructor();
	    private path;
	    private PI_2;
	    private _triangleNum;
	    private RADIUS_V;
	    drawGraph(): void;
	    get triangleNum(): number;
	    set triangleNum(value: number);
	    private setStarPath;
	}

}
declare module 'src/display/Arrow' {
	import { GraphBase } from 'src/display/private/GraphBase';
	export class Arrow extends GraphBase {
	    constructor();
	    private _angle;
	    drawGraph(): void;
	    private getArrowPath;
	}

}
declare module 'src/display/Ellipse' {
	import { GraphBase } from 'src/display/private/GraphBase';
	/**
	 * 绘制椭圆
	 *
	 * 不设置 lineWidth 或 color 椭圆不可见
	 *
	 */
	export class Ellipse extends GraphBase {
	    constructor();
	    drawGraph(): void;
	}

}
declare module 'src/display/Isosceles' {
	import { GraphBase } from 'src/display/private/GraphBase';
	/**
	 * 等腰梯形和等腰三角形(上边长度为0)
	 *
	 * 梯形上边的中点为中心点
	 *
	 * 不设置 lineWidth 或 color 矩形不可见
	 *
	 */
	export class Isosceles extends GraphBase {
	    constructor();
	    private _upLine;
	    private _downLine;
	    private _path;
	    get upLine(): number;
	    set upLine(value: number);
	    get downLine(): number;
	    set downLine(value: number);
	    drawGraph(): void;
	    private setIsosPath;
	}

}
declare module 'src/display/Graphics' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { GraphicsCore } from 'src/display/private/GraphicsCore';
	/**
	 * 矢量绘制
	 *
	 * @example let graphics = new vf.gui.Graphics();
	 *
	 */
	export class Graphics extends DisplayObject {
	    constructor(geometry?: vf.GraphicsGeometry | undefined);
	    readonly graphics: GraphicsCore;
	}

}
declare module 'src/display/private/selectedBounds' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	export enum BoundsEventType {
	    boundsScale = "boundsScale",
	    boundsAngle = "boundsAngle",
	    selectedBoundsClicked = "selectedBoundsClicked"
	}
	export class SelectedBounds extends DisplayObject {
	    constructor();
	    private _boundsRect?;
	    private _selectedRect?;
	    private _lastPos;
	    private _bounds;
	    private _uiContainer?;
	    private _cornerContainer?;
	    private onMove;
	    /**
	     * 向量的夹角
	     */
	    private measureAngle;
	    /**
	     * 添加选中时的8个小方块
	     */
	    private addSelectedShapeRect;
	    private getBoundsPosList;
	    /**
	     * 显示
	     */
	    show(parent: DisplayObject, bounds: vf.Rectangle, scaleX?: number, scaleY?: number, angle?: number, showCorner?: boolean): void;
	    /**
	     * 更新
	     */
	    update(parent: DisplayObject, bounds: vf.Rectangle, scaleX?: number, scaleY?: number, angle?: number, showCorner?: boolean): void;
	    /**
	     * 隐藏
	     */
	    hide(): void;
	}

}
declare module 'src/display/FollowLine' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { InteractionEvent } from 'src/interaction/Index';
	import { FollowLineEnum } from 'src/enum/Index';
	/**
	 * 跟随鼠标或触摸绘制线条
	 *
	 * @example let graphics = new vf.gui.FollowLine();
	 *
	 */
	export class FollowLine extends DisplayObject {
	    constructor();
	    /** 线条 */
	    private _lines;
	    /** 触摸的ID */
	    private _touchId;
	    /** 位置缓存，记录画线时候每一个点，最后画完优化 */
	    private _posCache;
	    /** 保存已画线的key */
	    private _lineKeys;
	    /** 鼠标坐标 */
	    private _mouseOffset;
	    /** 上次点击坐标 */
	    private _lastPos;
	    /**
	     * 划线索引, 取时间戳
	     */
	    private _curLineIndex;
	    /**
	     * 需要处理的消息列表
	     */
	    private _messageCache;
	    /**
	     * 线条颜色
	     */
	    lineColor: number;
	    /**
	     * 线条宽度
	     */
	    lineWidth: number;
	    /**
	     * 是否暂停，一些特殊情况，如拖拽时，可暂停
	     */
	    isPause: boolean;
	    /**
	     * LINES instead of TRIANGLE_STRIP
	     */
	    private lineType;
	    /**
	     * 是否启用橡皮檫
	     */
	    isErasing: boolean;
	    /** 角色状态 */
	    role: FollowLineEnum.Role;
	    /** 选择框的容器  */
	    private _selectedBounds?;
	    /** 要删除的线，复制品 */
	    private _eraseLine?;
	    set eraseLine(value: vf.Graphics | undefined);
	    get eraseLine(): vf.Graphics | undefined;
	    /**
	     * @private
	     * 提交属性，子类在调用完invalidateProperties()方法后，应覆盖此方法以应用属性
	     */
	    protected commitProperties(): void;
	    /**
	     * 更新显示列表,子类重写，实现布局
	     */
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    /**
	     * 添加选择框
	     */
	    private addSelectedBound;
	    private onMessage;
	    private addEvent;
	    private removeEvent;
	    onPress(e: InteractionEvent, thisObj: DisplayObject, isPress: boolean): void;
	    onMove(e: InteractionEvent): void;
	    /**
	     * 发送操作事件
	     * @param operate   1添加 2删除 3重置
	     * @param role  Role
	     * @param lineIndex 线段 ID
	     */
	    private emitMsg;
	    /**
	     *
	     * @param name (name = role + lineId)
	     * @param role
	     */
	    private getGraphics;
	    private getCurLineByPos;
	    private getDataStrByPosCache;
	    private drawLine;
	    private removeLine;
	    clear(): void;
	    setData(data: string | string[]): void;
	    reset(): any;
	    release(): void;
	}

}
declare module 'src/display/ConnectLine' {
	import { DisplayObject } from 'src/core/DisplayObject'; type LinePostion = 'leftTop' | 'centerTop' | 'rightTop' | 'leftCenter' | 'center' | 'rightCenter' | 'leftBottom' | 'centerBottom' | 'rightBottom' | number[];
	export const play: unique symbol;
	/**
	 * 连线组件
	 *
	 *
	 * @example let connectLine = new vf.gui.ConnectLine();
	 *
	 */
	export class ConnectLine extends DisplayObject {
	    constructor();
	    private readonly line;
	    private _lastStartPos;
	    private _lastEndPos;
	    private _play;
	    private _tw?;
	    /**
	     *  触发画线操作
	     *
	     *  属性 play = 1 触发画线，线条从source->target.
	     *  属性 play = 2 触发画线，线条从target->source.
	     */
	    get play(): 2 | 1;
	    set play(value: 2 | 1);
	    private _autoPlay;
	    /**
	     *  默认 autoPlay = true
	     *
	     *  autoPlay = true时，组件在设置source,target,sourcePostion,targetPostion后自动触发画线，线条从source->target.
	     *
	     *  autoPlay = false时，设置source,target,sourcePostion,targetPostion后不会触发画线，需调用 play.
	     */
	    get autoPlay(): boolean;
	    set autoPlay(value: boolean);
	    private _source?;
	    /**
	     * 设置源显示对象
	     */
	    get source(): DisplayObject | undefined;
	    set source(value: DisplayObject | undefined);
	    private _sourcePostion;
	    /**
	     * 设置源显示对象位置
	     */
	    get sourcePostion(): LinePostion;
	    set sourcePostion(value: LinePostion);
	    private _target?;
	    /**
	     * 设置目标显示对象
	     */
	    get target(): DisplayObject | undefined;
	    set target(value: DisplayObject | undefined);
	    private _targetPostion;
	    /**
	     * 设置目标显示对象位置
	     */
	    get targetPostion(): LinePostion;
	    set targetPostion(value: LinePostion);
	    /**
	     * 线条颜色
	     */
	    private _lineColor;
	    get lineColor(): number;
	    set lineColor(value: number);
	    /**
	     * 线条粗细
	     */
	    private _lineWidth;
	    get lineWidth(): number;
	    set lineWidth(value: number);
	    private _isAnimation;
	    /**
	     * 线条位置改变时，是否有动画
	     */
	    get isAnimation(): boolean;
	    set isAnimation(value: boolean);
	    private _speed;
	    /**
	     * 设置获取连线速度
	     */
	    get speed(): number;
	    set speed(value: number);
	    protected commitProperties(): void;
	    private getLocalPos;
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    private animation;
	    set isClear(value: boolean);
	    clear(): void;
	    release(): void;
	}
	export {};

}
declare module 'src/display/Tracing' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { ClickEvent } from 'src/interaction/Index';
	import { TracingEnum } from 'src/enum/Index';
	export class Tracing extends DisplayObject {
	    constructor();
	    protected clickEvent: ClickEvent;
	    private _renderMode;
	    private _guideSprite;
	    private _bgSprite;
	    private _lines;
	    private _realTraceIndexArr;
	    private _tempTraceIndexArr;
	    private _lineStyle;
	    private _posCache;
	    private _drawing;
	    private _lastLocalPos;
	    private _curLocalPos;
	    private _autoComplete;
	    private _curIndex;
	    private _tracePointObjArr;
	    private _result;
	    private _groupStatusArr;
	    private _lineId;
	    private _newLineFlag;
	    private _pointId;
	    private _messageCache;
	    private _tween;
	    private _guideTime;
	    private _strictFlag;
	    private _fillIndex;
	    /**
	     * debug
	     */
	    private _debug;
	    get debug(): boolean;
	    set debug(value: boolean);
	    /**
	     * 模式
	     */
	    private _mode;
	    set mode(value: TracingEnum.Mode);
	    get mode(): TracingEnum.Mode;
	    /**
	     * 文字轨迹图
	     */
	    private _traceSprite;
	    get traceSprite(): string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined;
	    set traceSprite(value: string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined);
	    /**
	     * 背景图，mask模式用于画线后漏出来
	     */
	    private _renderBgSprite;
	    get renderBgSprite(): string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined;
	    set renderBgSprite(value: string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined);
	    /**
	     * 轨迹点,二维数组
	     */
	    private _tracePoints;
	    get tracePoints(): {
	        x: number;
	        y: number;
	    }[][];
	    set tracePoints(value: {
	        x: number;
	        y: number;
	    }[][]);
	    /**
	     * 线宽
	     */
	    private _lineWidth;
	    get lineWidth(): number;
	    set lineWidth(value: number);
	    /**
	     * 颜色
	     */
	    private _lineColor;
	    get lineColor(): number;
	    set lineColor(value: number);
	    /**
	     * 检测精度
	     */
	    private _precision;
	    get precision(): number;
	    set precision(value: number);
	    /**
	     * 位图
	     */
	    private _lineTexture;
	    get lineTexture(): string | number | undefined;
	    set lineTexture(value: string | number | undefined);
	    /**
	     * 线透明度
	     */
	    private _lineOpacity;
	    get lineOpacity(): number | undefined;
	    set lineOpacity(value: number | undefined);
	    /**
	     * 画笔样式
	     */
	    private setLineStyle;
	    /**
	     * 轨迹图
	     */
	    private setTraceSprite;
	    /**
	     * mask背景图
	     */
	    private setRenderBgSprite;
	    /**
	     * 移出mask背景图
	     */
	    private removeRenderBgSprite;
	    /**
	     * 开始，适用于audo和teach模式
	     */
	    private start;
	    /**
	     * 教学引导
	     */
	    private guide;
	    private playGuideAnimal;
	    /**
	     * 清除教学引导
	     */
	    clearGuide(): void;
	    /**
	     * 自动绘制
	     */
	    private auto;
	    private _posLength;
	    private drawWithAnimation;
	    private autoNextPoint;
	    /**
	     * 更新显示列表,子类重写，实现布局
	     */
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    $onInit(): void;
	    $onRelease(): void;
	    /**
	     * 检测触摸点和轨迹点
	     * @param point
	     */
	    private checkTrace;
	    /**
	     * 检查暂存区,抬起时检测暂存区中的点是否在一个笔画上
	     */
	    private checkTemp;
	    /**
	     * 检查group
	     */
	    private checkResult;
	    private checkStrictFirstPoint;
	    private checkStrict;
	    private checkFill;
	    /**
	     * 教学模式检查
	     */
	    private checkTeach;
	    /**
	     * 画线
	     * @param lineId
	     * @param data
	     * @param from
	     * @param to
	     * @param lineStyle
	     */
	    private drawLine;
	    /**
	     * 绘图
	     * @param graphics
	     * @param posList
	     */
	    private draw;
	    /**
	     * 本地绘制
	     * @param graphics
	     */
	    private localDraw;
	    private onPress;
	    private onMove;
	    /**
	     *
	     * @param lineId
	     * @param lineStyle
	     */
	    private getGraphics;
	    private getDataStrByPosCache;
	    /**
	     * 发送一个笔画的msg
	     * @param lineId
	     * @param data
	     */
	    private emitTracingMsg;
	    private onMessage;
	    removeLine(lineId: string): void;
	    /**
	     * clear
	     */
	    clear(): void;
	    /**
	     * @private
	     * 提交属性，子类在调用完invalidateProperties()方法后，应覆盖此方法以应用属性
	     */
	    protected commitProperties(): void;
	    setData(data: string | string[]): void;
	    set source(data: string | string[]);
	}

}
declare module 'src/display/animation/Timeline' {
	export class Timeline<T> {
	    set defaultValue(value: T);
	    get curValue(): T;
	    set globalTime(v: number);
	    frames: Array<Frame<T>>;
	    private curTime;
	    lastTime: number;
	    loop: boolean;
	    totalTime: number;
	    protected _defaultValue: T;
	    protected _globalTime: number;
	    protected _lastGlobalTime: number;
	    protected _lastFrame: Frame<T> | null;
	    protected _curFrame: Frame<T> | null;
	    protected _nextFrame: Frame<T>;
	    protected _times: number;
	    protected _curValue: T;
	    constructor();
	    protected getProgress(cur: number, min: number, max: number, ease: ((k: number) => number) | any): number;
	    protected tick(): void;
	    protected updateCurFrame(): void;
	    protected updateCurValue(): void;
	    release(): void;
	}
	export class Frame<T> {
	    time: number;
	    ease?: ((k: number) => number) | any;
	    value: T;
	    getValue(progress: number, value: T): T;
	}
	export class NumberFrame extends Frame<number> {
	    constructor();
	    getValue(progress: number, value: number): number;
	}

}
declare module 'src/display/animation/PathTimeline' {
	import { Timeline } from 'src/display/animation/Timeline';
	export class PathTimeline extends Timeline<number> {
	    private path;
	    private length;
	    constructor(path: string);
	    get curPos(): [number, number];
	    get angle(): number;
	    release(): void;
	}

}
declare module 'src/display/animation/AnimationPath' {
	import { AnimationBase } from 'src/display/private/AnimationBase';
	export class AnimationPath extends AnimationBase {
	    private pathTimeline?;
	    constructor(sp?: any, options?: any, duratime?: number);
	    play(timer?: number): void;
	    gotoAndStop(timer: number): void;
	    protected updata(delta: number): void;
	    release(): void;
	}

}
declare module 'src/display/animation/Animation' {
	export class Animation {
	    private static _aniList;
	    static play(type: string, sprite: any, options: any, durtime?: number, callBack?: Function): any;
	    private static removeItem;
	    static releaseAll(): void;
	}

}
declare module 'src/display/private/AnimationBase' {
	///   types="@vf.js/vf" />
	export class AnimationBaseData {
	    x: number;
	    y: number;
	    rotation: number;
	}
	export class AnimationBase extends vf.utils.EventEmitter {
	    private _sprite;
	    protected _spriteData?: AnimationBaseData;
	    private _options;
	    private _duratime;
	    protected _currenTimer: number;
	    protected _revertAni: boolean;
	    private _playing;
	    private _valuesStart;
	    protected _toValue: any;
	    private _addTick;
	    constructor(sp?: any, options?: any, duratime?: number);
	    get playing(): boolean;
	    get sprite(): any;
	    set sprite(value: any);
	    get options(): any;
	    set options(value: any);
	    get revertAni(): boolean;
	    protected cacheSprite(): void;
	    play(curTimer?: number): void;
	    pause(): void;
	    /**
	     * 播放完成
	     */
	    complete(): void;
	    gotoAndPlay(timer: number): void;
	    gotoAndStop(timer: number): void;
	    /**
	     * 跳转
	     */
	    goto(timer: number): void;
	    /**
	     *
	     * 设置当前sprite状态
	     */
	    private setTimeStates;
	    /**
	     * 获取当前时间的sprite数据
	     * 如果重播时重头播放就可以  子类可以不用重写
	     *  每个动画计算方式不同 这个方法需要重写
	     */
	    getTimeData(timer: number): AnimationBaseData | undefined;
	    /**
	     *
	     */
	    protected updata(delta: number): void;
	    release(): void;
	}

}
declare module 'src/display/animation/AnimationJitter' {
	import { AnimationBase } from 'src/display/private/AnimationBase';
	export class AnimationJitter extends AnimationBase {
	    private tween;
	    constructor(sp?: any, options?: any, duratime?: number);
	    play(timer?: number): void;
	    gotoAndStop(timer: number): void;
	    private clearTween;
	    complete(): void;
	    release(): void;
	}

}
declare module 'src/interaction/AudioGroupController' {
	import { Audio } from 'src/display/Audio';
	interface AudioGroupObject {
	    groups: {
	        [key: string]: {
	            [value: string]: Audio;
	        };
	    };
	    values: {
	        [key: string]: string | undefined;
	    };
	}
	export const _audioGroupObject: AudioGroupObject;
	export function registrerAudioGroup(cb: Audio): void;
	/**
	 * 注销指定分组或指定分组的子项
	 * @param cb video
	 */
	export function unRegistrerAudioGroup(cb: Audio): void;
	/** 更新分组中选中的checkbox组件  */
	export function updateAudioGroupStates(cb: Audio): void;
	export {};

}
declare module 'src/display/Audio' {
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 * 音频组件
	 *
	 * 准备完成 canplaythrough
	 *
	 * 播放事件 play
	 *
	 * 暂停事件 pause
	 *
	 * 错误事件 error
	 *
	 * 播放时间改变 timeupdate
	 *
	 * 播放完成 ended
	 *
	 * @example let audio = new vf.gui.Audio();
	 *
	 *
	 */
	export enum PlayerStates {
	    init = "init",
	    play = "play",
	    pause = "pause",
	    end = "end"
	}
	export class Audio extends DisplayObject {
	    private audio?;
	    private _id;
	    private _src;
	    private _autoplay;
	    private _loop;
	    private _playbackRate;
	    private _volume;
	    private _audioUid;
	    private _playerStates;
	    private stoping;
	    constructor();
	    set audioUid(value: string);
	    private initAudio;
	    /**
	    * 设置src 支持3种 url base64 arraybuffer;
	    */
	    set src(value: any);
	    get src(): any;
	    set autoplay(value: boolean);
	    get autoplay(): boolean;
	    set loop(value: boolean);
	    get loop(): boolean;
	    set playbackRate(value: number);
	    get playbackRate(): number;
	    set volume(value: number);
	    get volume(): number;
	    get duration(): number;
	    get paused(): boolean;
	    /**
	    * 设置分组名
	    */
	    get audioGroup(): string | undefined;
	    set audioGroup(value: string | undefined);
	    get playerStates(): PlayerStates;
	    get isPlaying(): boolean;
	    /**
	    * 支持的方法们~~~··~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	    *    */
	    /**
	     * 声音播放接口
	     *
	     *  await sound.play()
	     * @param {number} [time] - 声音延迟开始
	     * @param {number} [offset] - 声音的开始偏移值
	     * @param {number} [length] - 声音持续时间（以秒为单位）
	     */
	    play(time?: number, offset?: number, length?: number): void;
	    /**
	    * 停止声音
	    * @param time (optional) X秒后停止声音。默认情况下立即停止
	    */
	    stop(time?: number): void;
	    /**
	    * 暂停声音
	    */
	    pause(): void;
	    /**
	    * 释放
	    */
	    dispose(): void;
	    release(): void;
	    /**
	    * 各种可取参数.~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	    */
	    protected commitProperties(): void;
	    private useNativeAudio;
	    private nativeEmit;
	}

}
declare module 'src/event/SchedulerEvent' {
	export const enum SchedulerEvent {
	    /**
	     * 心跳
	     */
	    TICK = "tick",
	    /**
	     * 启动/开始
	     */
	    START = "start",
	    /**
	     * 更新
	     */
	    UPDATE = "update",
	    /**
	     * 结束
	     */
	    END = "end"
	}

}
declare module 'src/event/Index' {
	import * as ComponentEvent from 'src/event/ComponentEvent';
	import { InteractionEvent } from 'src/event/InteractionEvent';
	import { TouchMouseEvent } from 'src/event/TouchMouseEvent';
	import { TweenEvent } from 'src/event/TweenEvent';
	import { SchedulerEvent } from 'src/event/SchedulerEvent';
	export { ComponentEvent, InteractionEvent, TouchMouseEvent, TweenEvent, SchedulerEvent };

}
declare module 'src/display/PathGraphics' {
	import { GraphBase } from 'src/display/private/GraphBase';
	export enum ArrowType {
	    None = 0,
	    HollowCircle = 1,
	    FullCircle = 2,
	    HollowRect = 3,
	    FullRect = 4,
	    HollowArrow = 5,
	    FullArrow = 6,
	    line = 7
	}
	/**
	 * 矢量绘制
	 *
	 * @example let graphics = new vf.gui.Graphics();
	 *
	 */
	export class PathGraphics extends GraphBase {
	    constructor();
	    private _path;
	    private _pathData;
	    private _beginPort;
	    private _endPort;
	    private _graphicsBegin;
	    private _graphicsEnd;
	    private _beginRotation;
	    private _endRotation;
	    private _isSvgPath;
	    get path(): string;
	    set path(value: string);
	    get beginPort(): ArrowType;
	    set beginPort(value: ArrowType);
	    get endPort(): ArrowType;
	    set endPort(value: ArrowType);
	    drawGraph(): void;
	    private getType;
	    /**
	     * 新的解析方式
	     */
	    private drawInfoData;
	    private drawBeginPort;
	    private drawEndPort;
	    private drawShape;
	    /**
	  * svg格式线条 解析
	  *
	  * M 表示MoveTo
	   *   L 表示LineTo，
	   *   Q表示二次贝塞尔曲线
	   *   C 表示三次贝塞尔曲线
	  */
	    release(): void;
	}

}
declare module 'src/display/Alert' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { DisplayLayoutAbstract } from 'src/core/DisplayLayoutAbstract';
	export interface ButtonInfo {
	    btnNormal?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    btnHover?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    btnPressed?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    text?: string;
	}
	export class Alert extends DisplayObject {
	    static show(container: DisplayLayoutAbstract, content: string, textAlign?: string, duration?: number, icon?: number | string | vf.Texture, title?: string, buttons?: string[], x?: number, y?: number): Alert;
	    constructor();
	    /**
	     * 弹框标题
	     */
	    private _title;
	    set title(value: string);
	    get title(): string;
	    /**
	     * 弹框内容
	     */
	    private _content;
	    set content(value: string);
	    get content(): string;
	    /**
	     * 按钮内容
	     */
	    private _buttons;
	    set buttons(value: string[]);
	    get buttons(): string[];
	    private _imgButtons;
	    set imgButtons(value: ButtonInfo[]);
	    get imgButtons(): ButtonInfo[];
	    /**
	     * 自动弹出
	     */
	    autoShow: boolean;
	    /**
	     * 自动释放
	     */
	    autoRelease: boolean;
	    /**
	     * 持续时间
	     */
	    duration: number;
	    /**
	     * 内容对齐方式  //left  center
	     */
	    textAlign: string;
	    /**
	     * 按钮默认宽高
	     */
	    buttonWidth: number;
	    buttonHeight: number;
	    /**
	     * 背景遮罩颜色透明度
	     */
	    maskColor: number;
	    maskOpacity: number;
	    /**
	     * 皮肤样式
	     */
	    icon?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    background?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    btnNormal?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    btnHover?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    btnPressed?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    backgroundColor: number;
	    titleColor: number;
	    contentColor: number;
	    btnColors: number[];
	    btnTextColors: number[];
	    /**
	     * 显示状态
	     */
	    private _isShowing;
	    /**
	     * 组件显示对象
	     */
	    private _bgDisplay?;
	    private _titleDisplay?;
	    private _lineDisplay?;
	    private _contentDisplay?;
	    private _iconDisplay?;
	    private _buttonsDisplays;
	    protected commitProperties(): void;
	    /**
	     * 初始化显示
	     */
	    private initDisplay;
	    private _updateDisplayList;
	    /**
	     * 显示弹出框
	     */
	    show(): void;
	    /**
	     * 关闭弹出框
	     */
	    close(): void;
	    /**
	     * 释放
	     */
	    release(): void;
	    private onHover;
	    private onPress;
	    private onClick;
	}

}
declare module 'src/display/AutoContainer' {
	import { DisplayObjectAbstract } from 'src/core/DisplayObjectAbstract';
	import { Scheduler } from 'src/core/Scheduler';
	import { TimeLine } from 'src/tween/TimeLine';
	import { Tween } from 'src/tween/Tween';
	import { Container } from 'src/display/Container';
	/**
	 * 自动容器，提供各种组件的构造接口， timeline、tween、schedule的自动释放
	 * 手写代码构建scene的最佳实践：
	 * class Scene extends vf.gui.AutoContainer{
	 *
	 * }
	 */
	export class AutoContainer extends Container {
	    constructor();
	    private idCountDict;
	    private timeLineList;
	    private tweenList;
	    private schedulerList;
	    createDisplayObject(moduleName: string, option: any, parent?: DisplayObjectAbstract): any;
	    createTimeLine(option: any): TimeLine;
	    createTween(object: any): Tween;
	    setTimeout(time: number, callFunc: (data?: any) => void): Scheduler;
	    setInterval(time: number, callFunc: (data?: any) => void): Scheduler;
	    setEnterFrame(callFunc: (data?: any) => void): Scheduler;
	    release(): void;
	}

}
declare module 'src/UI' {
	///   types="@vf.js/vf" />
	/** 工具类 */
	import * as Utils from 'src/utils/Utils';
	/** UI舞台，最顶级的层 展示所有UI组件 */
	import { Stage } from 'src/core/Stage';
	/** UI基础显示对象，一般不会直接使用，只作为类型推断 */
	import { DisplayObject } from 'src/core/DisplayObject';
	/** 心跳，需要在初始化完成后，启动心跳更新 */
	import { TickerShared } from 'src/core/Ticker';
	/** 滤镜的基础类 */
	import { Filter } from 'src/core/Filter';
	/**
	 * 基础容器
	 *
	 * 设置checkGroup后，进行分组。 分组后，可理解为复选框。
	 *
	 * @example let container = new vf.gui.Container();
	 *
	 */
	import { Container } from 'src/display/Container';
	/**
	 * 滚动容器
	 *
	 * @example let scrollingContainer = new vf.gui.ScrollingContainer();
	 *
	 */
	import { ScrollingContainer } from 'src/display/ScrollingContainer';
	/**
	 * 图片
	 *
	 * @example let image = new vf.gui.Image();
	 *
	 *
	 */
	import { Image } from 'src/display/Image';
	/**
	 * 序列图动画
	 *
	 * 支持使用texturepacker导出以及处理轴点
	 *
	 * @example let spriteAnimated = new vf.gui.SpriteAnimated();
	 *
	 */
	import { SpriteAnimated } from 'src/display/SpriteAnimated';
	/**
	 * 文本
	 *
	 * 中文换行特殊处理 xxxx.style.breakWords = true;
	 *
	 * 文本没有宽高，自适应
	 *
	 * @example let label = new vf.gui.Label();
	 *
	 *
	 */
	import { Label } from 'src/display/Label';
	/**
	 * 文本输入
	 *
	 * @example let textInput = new vf.gui.TextInput(true|false);//单行或多行
	 *
	 *
	 */
	import { TextInput } from 'src/display/TextInput';
	/**
	 * 滑动条/进度条
	 *
	 * @example let slider = new vf.gui.Slider();
	 *
	 */
	import { Slider } from 'src/display/Slider';
	/**
	 * 按钮
	 *
	 * @example let button = new vf.gui.Button();
	 *
	 */
	import { Button } from 'src/display/Button';
	/**
	 * 单选\复选框
	 *
	 * 设置checkGroup后，进行分组。 分组后，可理解为复选框。
	 *
	 * @example let checkBox = new vf.gui.CheckBox();
	 *
	 *
	 */
	import { CheckBox } from 'src/display/CheckBox';
	/**
	 * 绘制矩形或圆角矩形
	 *
	 * @example let rect = new vf.gui.Rect();
	 *
	 *
	 */
	import { Rect } from 'src/display/Rect';
	/**
	 * 绘制矩形或圆角矩形
	 *
	 * @example let rect = new vf.gui.Circle();
	 *
	 *
	 */
	import { Circle } from 'src/display/Circle';
	/**
	 * 星型绘制
	 *
	 */
	import { Star } from 'src/display/Star';
	/**
	 * 多边形绘制
	 *
	 */
	import { Polygon } from 'src/display/Polygon';
	/**
	 * 箭头绘制
	 *
	 */
	import { Arrow } from 'src/display/Arrow';
	/**
	 * 椭圆绘制
	 *
	 */
	import { Ellipse } from 'src/display/Ellipse';
	/**
	 * 等腰绘制
	 *
	 */
	import { Isosceles } from 'src/display/Isosceles';
	/**
	 * 矢量绘制
	 *
	 * @example let graphics = new vf.gui.Graphics();
	 *
	 *
	 */
	import { Graphics } from 'src/display/Graphics';
	/**
	 * 跟随划线（鼠标或触摸按下时）
	 *
	 * @example let graphics = new vf.gui.FollowLine();
	 *
	 *
	 */
	import { FollowLine } from 'src/display/FollowLine';
	import { Video } from 'src/display/Video';
	/**
	 * 连线组件
	 *
	 *
	 * @example let connectLine = new vf.gui.ConnectLine();
	 *
	 *
	 */
	import { ConnectLine } from 'src/display/ConnectLine';
	/**
	 * 临摹组件
	 *
	 * @example let Tracing = new vf.gui.Tracing();
	 *
	 */
	import { Tracing } from 'src/display/Tracing';
	/**
	 * 滚动组件
	 *
	 * @example let scrollBar = new vf.gui.ScrollBar();
	 *
	 *
	 */
	import { ScrollBar } from 'src/display/ScrollBar';
	/**
	 * 完整的缓动曲线列表
	 *
	 * @example vf.gui.Easing.Linear.None;
	 *
	 *
	 */
	import { Easing } from 'src/tween/Easing';
	/**
	 * 缓动动画
	 *
	 * @example let tween = new vf.gui.Tween(myObject).to({width:'300px'}, 2000).start()
	 *
	 *
	 */
	import { Tween } from 'src/tween/Tween';
	/**
	 * 动画时间轴
	 */
	/**
	 * 振动动画
	 */
	import { AnimationJitter } from 'src/display/animation/AnimationJitter';
	import { Animation } from 'src/display/animation/Animation';
	import { NumberFrame } from 'src/display/animation/Timeline';
	/**
	 * 基于帧的时间轴控制类
	 *
	 * @example let timeline = new vf.gui.Timeline();
	 *
	 *
	 */
	import { TimeLine } from 'src/tween/TimeLine';
	/**
	 * 音频
	 *
	 *
	 *
	 * 估计是能播放  没毛病
	 *
	 * @example let audio = new vf.gui.Audio(“地址或者是arrbuffer”);
	 *
	 *
	 */
	import { Audio } from 'src/display/Audio';
	/**
	 * 事件绑定类，非继承于inputbase的组件是没有任何交互事件，需单独绑定
	 */
	import * as Interaction from 'src/interaction/Index';
	/**
	 * 事件名
	 */
	import * as Event from 'src/event/Index';
	/**
	 * 枚举
	 */
	import * as Enum from 'src/enum/Index';
	import { Scheduler } from 'src/core/Scheduler';
	import { SyncManager } from 'src/interaction/SyncManager';
	/**
	 *  路线绘制
	 */
	import { PathGraphics } from 'src/display/PathGraphics';
	import { Alert } from 'src/display/Alert';
	/**
	 * 自动容器
	 */
	import { AutoContainer } from 'src/display/AutoContainer';
	export type Application = vf.Application;
	/** 请不要在编写UI组件内部使用本类 */
	export { Audio, Filter, Utils, Stage, Container, AutoContainer, ScrollingContainer, Slider, Label, TextInput, Button, Video, CheckBox, Rect, Circle, Star, Arrow, Ellipse, Isosceles, Graphics, FollowLine, Tracing, ConnectLine, ScrollBar, Polygon, Interaction, DisplayObject, TickerShared, Tween, TimeLine, Easing, Image, SpriteAnimated, Event, Enum, Scheduler, NumberFrame, PathGraphics, AnimationJitter, Animation, SyncManager, Alert, };

}
declare module 'src/vf-gui' {
	import * as gui from 'src/UI';
	export { gui };

}
declare interface ObjectConstructor {
    assign(...objects: Record<string, any>[]): Record<string, any>;
}
interface ArrayConstructor {
    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
    from<T>(arrayLike: ArrayLike<T>): T[];
}
interface String {
    startsWith(searchString: string, position?: number): boolean;
}
interface TInputBase {
    blur?: Function;
    focus?: Function;
}
interface InputStyle {
    [propName: string]: any;
    fontFamily: string;
    fontSize?: string;
    fontWeight?: string;
    fontVariant: "normal" | "small-caps" | "inherit";
    color: '#000000';
    padding: string;
    multiline: boolean;
    fontStyle: "normal" | "italic" | "oblique" | "inherit";
    letterSpacing: number;
    textIndent: string;
    position: 'absolute';
    background: 'none';
    border: 'none';
    outline: 'none';
    transformOrigin: '0 0';
    lineHeight: '1';
}
interface Lifecycle {
    /**
     * 组件加载，暂时可能用不到
     */
    load(): void;
    /**
     * 释放，回收
     */
    release(): void;
}
/**
 * 生命周期的接口
 */
interface LifecycleHook {
    /**
     * 显示对象初始化完成，只执行一次,子类重写，不可外部调用
     */
    $onInit(): void;
    /**
     * 加载完成，不可外部调用
     */
    $onLoad(): void;
    /**
     * 回收，释放完成，不可外部调用
     */
    $onRelease(): void;
    /**
     * 添加到舞台后，不可外部调用
     */
    $onAddStage(): void;
    /**
     * 移出舞台后，不可外部调用
     */
    $onRemoveStage(): void;
}
declare module 'src/core/UIBase' {
	import { DisplayObject } from 'src/core/DisplayObject';
	export class UIBase extends DisplayObject implements Lifecycle {
	    constructor();
	}

}
declare module 'src/display/Pasition' {
	export class PasitionOptions {
	    from: any;
	    to: any;
	    duration: number;
	    mustSvgData?: boolean | undefined;
	    easing?: ((k: number) => number) | any;
	    onStart?: Function;
	    onUpdate?: Function;
	    onEnd?: Function;
	}
	export class Pasition {
	    private MIM_CURVES_COUNT;
	    private _beginTime;
	    private _pathArr;
	    private _pathB;
	    private _options?;
	    constructor(option?: PasitionOptions);
	    get from(): any;
	    set from(value: any);
	    get to(): any;
	    set to(value: any);
	    get duration(): number;
	    set duration(value: number);
	    get onStart(): Function | undefined;
	    set onStart(value: Function | undefined);
	    get onUpdate(): Function | undefined;
	    set onUpdate(value: Function | undefined);
	    get onEnd(): Function | undefined;
	    set onEnd(value: Function | undefined);
	    get easing(): any;
	    set easing(value: any);
	    get options(): PasitionOptions;
	    /**
	     * 动画初始值
	     */
	    play(): void;
	    /**
	     * 刷新
	     */
	    private onUpdata;
	    private _lerp;
	    private lerpCurve;
	    private lerpPoints;
	    /**
	     * 保持线条长度和关键点数相同
	     */
	    private _preprocessing;
	    private _splitCurves;
	    private split;
	    private _split;
	    private sync;
	    /**
	     * 取移动点最短距离的方案
	     */
	    private sort;
	    private boxDistance;
	    private sortCurves;
	    private permuteCurveNum;
	    private curveDistance;
	    private shapeBox;
	    private permuteNum;
	    private permute;
	    release(): void;
	}

}
declare module 'src/enum/ComponentEvent' {
	/**
	 * 特定属性改变时,通常为了去系统事件区分，UI组件的事件名为大写
	 * 1. CheckBox 的 checked 改变时
	 * 2. Label 的 text 改变时
	 * 3. SpriteAnimated 的 animationName 改变时
	 * 4. Button 文字改变
	 * 5. ScrollingContainer 拖动改变时
	 * 6. Slider 滑动改变后
	 * 7. SpriteAnimated 动画改变后
	 * 8. ConnectLine 连线完成时
	 * 9. Tracing 临摹完成一个笔画
	 */
	export const CHANGE = "CHANGE";
	/**
	 * 状态改变中
	 *
	 * slider 滑动时
	 */
	export const CHANGEING = "CHANGEING";
	/**
	 * 状态切换完成时
	 *
	 * 1. SpriteAnimated 每次播放完时，触发(loop = false时)
	 * 2. Image 图片加载完成时
	 * 3. Slider 滑动完成
	 * 4. Timeline  每次播放完时，触发(loop = false时)
	 * 5. FollowLine 完成一次划线
	 * 6. Tracing 临摹全部完成
	 */
	export const COMPLETE = "COMPLETE";
	/**
	 * 状态发生改变时
	 */
	export const STATE_CHANGE = "STATE_CHANGE";
	/**
	 * 状态切换完成时
	 *
	 * SpriteAnimated 每次播放完时，，触发(loop = true时)
	 */
	export const LOOP = "LOOP";
	/**
	 * 组件被添加前
	 */
	export const ADD = "add";
	/**
	 * 组件被添加时
	 */
	export const ADDED = "added";
	/**
	 * 组件被移除时
	 */
	export const REMOVEED = "removed";
	/**
	 * 组件大小改变后
	 */
	export const RESIZE = "RESIZE";
	/**
	 * 组件位置移动
	 */
	export const MOVE = "MOVE";
	/**
	 * 组件创建完成后
	 */
	export const CREATION_COMPLETE = "CREATION_COMPLETE";
	/**
	 * 组件拖动开始之前
	 */
	export const DRAG_START_BEFORE = "DRAG_START_BEFORE";
	/**
	 * 组件拖动开始时
	 */
	export const DRAG_START = "DRAG_START";
	/**
	 * 组件拖动结束之前
	 */
	export const DRAG_END_BEFORE = "DRAG_END_BEFORE";
	/**
	 * 组件拖动结束时 （如果绑定接收容器并拖动到接收容器中，不会触发此事件）
	 */
	export const DRAG_END = "DRAG_END";
	/**
	 * 组件拖动中
	 */
	export const DRAG_MOVE = "DRAG_MOVE";
	/**
	 * 组件拖动到接收目标中之前
	 */
	export const DRAG_TARGET_BEFORE = "DRAG_TARGET_BEFORE";
	/**
	 * 组件拖动到接收目标中
	 */
	export const DRAG_TARGET = "DRAG_TARGET";
	/**
	 * 有拖拽物掉落到此容器时触发
	 */
	export const DROP_TARGET = "DROP_TARGET";
	/**
	 * 播放音效 {name,mode}
	 */
	export const PLAY_AUDIO = "PLAY_AUDIO";

}
declare module 'src/interaction/KeyboardEvent' {
	import { DisplayObject } from 'src/core/DisplayObject'; class KeyboardSelectEvent {
	    /**
	     * document的键盘事件
	    */
	    constructor();
	    private obj;
	    private ctrlDown;
	    private shiftDown;
	    private shiftKey;
	    private ctrlKey;
	    private cmdKey;
	    private isAddEvent;
	    private keyDownEventBind;
	    private keyUpEventBind;
	    private pasteEventBind;
	    private copyEventBind;
	    private cutEventBind;
	    private addEvent;
	    private removeEvent;
	    protected keyDownEvent(e: KeyboardEvent): void;
	    protected keyUpEvent(e: KeyboardEvent): void;
	    protected copyEvent(e: ClipboardEvent): void;
	    protected cutEvent(e: ClipboardEvent): void;
	    protected pasteEvent(e: ClipboardEvent): void;
	    focus(obj: DisplayObject): void;
	    blur(): void;
	}
	/**
	 * KeyboardSelectEvent 的实例
	 */
	export const keyboardShared: KeyboardSelectEvent;
	export {};

}
declare module 'src/tween/private/PlaybackPosition' {
	/**
	 * 回放位置的相关操作函数
	 */
	export default class PlaybackPosition {
	    constructor();
	    private totalTime;
	    private labels;
	    private offsets;
	    parseLabel(_name: string, offset: string | number | null): number;
	    addLabel(_name: string, offset: string | number | null): this;
	    setLabel(_name: string, offset: string | number | null): this;
	    eraseLabel(_name: string, offset: string | number | null): this;
	}

}
declare module 'src/interaction/TouchMouseEventEnum' {
	/**
	 * 鼠标点击与触摸事件枚举,内部DisplayObject使用
	 * @since 1.0.0
	 */
	export const enum TouchMouseEventEnum {
	    mousedown = "mousedown",
	    mousemove = "mousemove",
	    mouseup = "mouseup",
	    mouseover = "mouseover",
	    mouseout = "mouseout",
	    mouseupoutside = "mouseupoutside",
	    mouseRightDown = "rightdown",
	    mouseRightup = "rightup",
	    mouseRightupoutside = "rightupoutside",
	    touchstart = "touchstart",
	    touchcancel = "touchcancel",
	    touchend = "touchend",
	    touchendoutside = "touchendoutside",
	    touchmove = "touchmove",
	    tap = "tap"
	}

}
declare module 'src/event/InteractionEvent' {
	///   types="@vf.js/vf" />
	/**
	 * 事件的基础类
	 *
	 * 触摸或鼠标操作事件 可查看 -> TouchEventEnum.TouchEnum
	 *
	 * import InteractionEvent from "../interaction/InteractionEvent",
	 */
	export class InteractionEvent extends vf.InteractionEvent {
	    constructor();
	    local: vf.Point;
	    path?: number[];
	    signalling: boolean;
	}

}
declare module 'src/event/TouchMouseEvent' {
	/**
	 * 对外，封装的点击触摸事件
	 *
	 * import InteractionEvent,{Mouse} from "../interaction/InteractionEvent",
	 */
	export const TouchMouseEvent: {
	    /**
	     * 移出
	     *
	     * (e: InteractionEvent,thisObj:DisplayObject,over: boolean)=>{}
	     */
	    onHover: string;
	    /**
	     * 按下
	     *
	     * (e: InteractionEvent,thisObj:DisplayObject, isPressed: boolean)=>void
	     */
	    onPress: string;
	    /**
	     * 按下
	     */
	    onDown: string;
	    /**
	     * 弹起
	     */
	    onUp: string;
	    /**
	     * 点击
	     *
	     * (e: InteractionEvent,thisObj:DisplayObject)=>void
	     */
	    onClick: string;
	    /**
	     * PC 特有，右键点击
	     *
	     * (e: InteractionEvent,thisObj:DisplayObject)=>void
	     */
	    onRightDown: string;
	    /**
	     * 移动
	     *
	     * (e: InteractionEvent,thisObj:DisplayObject)=>void
	     */
	    onMove: string;
	    /**
	     * 鼠标移入
	     *
	     * (e: InteractionEvent,thisObj:DisplayObject)=>void
	     */
	    onMouseEnter: string;
	    /**
	     * 鼠标移出
	     *
	     * (e: InteractionEvent,thisObj:DisplayObject)=>void
	     */
	    onMouseLeave: string;
	};

}
declare module 'src/tween/Easing' {
	/**
	 * 完整的缓动曲线列表
	 *
	 * @example vf.gui.Easing.Linear.None;
	 *
	 */
	export const Easing: {
	    Linear: {
	        None(k: number): number;
	    };
	    Quadratic: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Cubic: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Quartic: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Quintic: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Sinusoidal: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Exponential: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Circular: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Elastic: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Back: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Bounce: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Stepped: {
	        steps: (steps: number) => (k: number) => number;
	    };
	};

}
declare module 'src/tween/private/constants' {
	/**
	 * 卡帧后的平滑处理帧率
	 */
	export const FRAME_MS: number;
	/**
	 * 平滑处理允许的触发时间
	 */
	export const TOO_LONG_FRAME_MS = 250;
	/**
	 * 链式补间动画的key前缀
	 */
	export const CHAINED_TWEENS = "_chainedTweens";
	export const STRING_PROP = "STRING_PROP";
	export const NUM_REGEX: RegExp;
	export function decomposeString(fromValue: string | any): any;
	export function decompose(prop: any, obj: any, from: any, to: any): any;
	export const RGB = "rgb(";
	export const RGBA = "rgba(";
	export function isRGBColor(v: any, i: number, r?: string): boolean;
	export function recompose(prop: any, obj: any, from: any, to: any, t: any, originalT: any, stringBuffer?: any): any;
	export const SET_NESTED: (nested: any) => any;

}
declare module 'src/tween/private/Interpolation' {
	/**
	 * 差值计算列表
	 * @example
	 *
	 * let bezier = vf.gui.tween.Interpolation.Bezier
	 * new vf.gui.tween.Tween({x:0}).to({x:[0, 4, 8, 12, 15, 20, 30, 40, 20, 40, 10, 50]}, 1000).interpolation(bezier).start()
	 * @memberof vf.gui.tween
	 */
	export const Interpolation: {
	    Linear(v: any, k: number, value: any): any;
	    Bezier(v: any, k: number, value: any): any;
	    CatmullRom(v: any, k: number, value: any): any;
	    Utils: {
	        Linear(p0: any, p1: any, t: any, v: any): any;
	        Reset(value: any): any;
	        Bernstein(n: any, i: any): number;
	        Factorial: (n: any) => number;
	        CatmullRom(p0: any, p1: any, p2: any, p3: any, t: any, v?: any): any;
	    };
	};

}
declare module 'src/event/TweenEvent' {
	/**
	 * 缓动事件
	 */
	export const TweenEvent: {
	    /**
	     *
	     */
	    Callback: string;
	    /**
	     * 每次改变
	     */
	    update: string;
	    /**
	     * 完成
	     */
	    complete: string;
	    /**
	     * 开始时
	     */
	    start: string;
	    /**
	     * 每次重复时
	     */
	    repeat: string;
	    /**
	     * 反向时
	     */
	    reverse: string;
	    /**
	     * 暂停时
	     */
	    pause: string;
	    /**
	     * 播放时
	     */
	    play: string;
	    /**
	     * 重新开始时
	     */
	    restart: string;
	    /**
	     * 停止时
	     */
	    stop: string;
	};

}
declare module 'src/tween/Tween' {
	///   types="@vf.js/vf" />
	import { add, get, getAll, remove, removeAll, removeDisplay, update } from 'src/tween/private/core';
	/**
	 * 缓动动画
	 *
	 * @example let tween = new vf.gui.Tween(myObject).to({width:'300px'}, 2000).start()
	 *
	 */
	export class Tween extends vf.utils.EventEmitter {
	    static core: {
	        add: typeof add;
	        get: typeof get;
	        getAll: typeof getAll;
	        remove: typeof remove;
	        removeAll: typeof removeAll;
	        removeDisplay: typeof removeDisplay;
	        update: typeof update;
	    };
	    static Event: {
	        Callback: string;
	        update: string;
	        complete: string;
	        start: string;
	        repeat: string;
	        reverse: string;
	        pause: string;
	        play: string;
	        restart: string;
	        stop: string;
	    };
	    /**
	     * Easier way to call the Tween
	     * @param {object} object - Initial value
	     * @param {object} to - Target value
	     * @param {object} params - Options of tweens
	     * @example Tween.fromTo(myObject, {x:0}, {x:200},1000)
	     * @memberof vf.gui.Tween
	     * @static
	     */
	    static fromTo(object: any, to: any, duration?: number): Tween;
	    /**
	     * Easier way calling constructor only applies the `to` value, useful for CSS Animation
	     * @param {any} object object
	     * @param {object} to - Target value
	     * @param {object} params - Options of tweens
	     * @example Tween.to(myObject, {x:200}, 1000)
	     * @memberof vf.gui.Tween
	     * @static
	     */
	    static to(object: any | any[], to: any, duration?: number): Tween;
	    /**
	     * Easier way calling constructor only applies the `from` value, useful for CSS Animation
	     * @param {any} object object
	     * @param {object} from - Initial value
	     * @param {object} params - Options of tweens
	     * @example Tween.from(myObject, {x:200}, 1000)
	     * @memberof vf.gui.Tween
	     * @static
	     */
	    static from(object: any, from: any, duration?: number): Tween;
	    constructor(object?: any);
	    id: number;
	    object: any;
	    private _valuesEnd;
	    private _valuesStart;
	    _virtualValueStart: any;
	    protected _duration: number;
	    private _easingFunction;
	    private _easingReverse;
	    private _interpolationFunction;
	    protected _startTime: number;
	    protected _delayTime: number;
	    private _repeat;
	    private _initRepeat;
	    _isPlaying: boolean;
	    private _yoyo;
	    private _reversed;
	    private _onStartCallbackFired;
	    private _isFinite;
	    private _prevTime;
	    private _rendered;
	    private _reverseDelayTime;
	    /** 附加数据 */
	    data: {
	        [key: string]: any;
	    };
	    /**
	     *
	     * 外部使用回调函数   这里用于timeLine给每个tween设置事件回调
	     */
	    onUpdate?: Function;
	    onUpdateParams?: any;
	    onStart?: Function;
	    onStartParams?: any;
	    onComplete?: Function;
	    onCompleteParams?: any;
	    onRepeat?: Function;
	    onRepeatParams?: any;
	    onReverseComplete?: Function;
	    onReverseCompleteParams?: any;
	    private _needDownGrade;
	    setObject(object: any): void;
	    onFunction(eventType: string, object: any, elapsed?: any): void;
	    get needDownGrade(): boolean;
	    set needDownGrade(value: boolean);
	    /**
	     * 是否在播放中
	     * @return {boolean}
	     * @example tween.isPlaying()
	     * @memberof vf.gui.Tween
	     */
	    get isPlaying(): boolean;
	    set isPlaying(value: boolean);
	    get valuesEnd(): any;
	    get valuesStart(): any;
	    /**
	     * 是否开始播放
	     * @return {boolean}
	     * @example tween.isStarted()
	     * @memberof vf.gui.Tween
	     */
	    get isStarted(): boolean;
	    get delayTime(): number;
	    /**
	     * 获取动画的开始时间
	     */
	    get startTime(): number;
	    /**
	     * 获取动画的开始时间
	     */
	    set startTime(value: number);
	    /**
	     * 设置缓动时长
	     * @param {number} amount 持续的毫秒值
	     * @example tween.duration(2000)
	     * @memberof vf.gui.Tween
	     * @deprecated 不推荐使用这个方法，内部使用
	     * @private
	     */
	    set duration(amount: number | Function);
	    get duration(): number | Function;
	    /**
	     * 逆向缓动
	     * @example tween.reverse()
	     * @param {boolean=} state 是否逆向
	     * @memberof vf.gui.Tween
	     */
	    reverse(state?: boolean, timer?: number): this;
	    /**
	     * 当前动画是否逆转
	     * @return {boolean}
	     * @example tween.reversed() true逆向中
	     * @memberof vf.gui.Tween
	     */
	    reversed(): boolean;
	    /**
	     * 暂停缓动
	     * @example tween.pause()
	     * @memberof vf.gui.Tween
	     */
	    pause(): boolean | this;
	    /**
	     * 播放或恢复播放
	     * @example tween.play()
	     * @memberof vf.gui.Tween
	     */
	    play(): boolean | this;
	    /**
	     * 设置要缓动的目标属性与持续时间
	     * @param {object} properties 目标属性值
	     * @param {number|Object=} [duration=1000] 持续时间
	     * @example let tween = new vf.gui.Tween({x:0}).to({x:100}, 2000)
	     * @memberof vf.gui.Tween
	     */
	    to(properties: any, duration?: number): this;
	    private render;
	    /**
	     * 开始执行缓动
	     * @example tween.start()
	     * @memberof vf.gui.Tween
	     */
	    start(): this;
	    private toEnd;
	    /**
	     * 停止缓动
	     * @example tween.stop()
	     * @memberof vf.gui.Tween
	     */
	    stop(): boolean | this;
	    /**
	     * 设置延迟执行时间
	     * @param {number} amount 延迟等待的时间，毫秒
	     * @example tween.delay(500)
	     * @memberof vf.gui.Tween
	     */
	    delay(amount: number): this;
	    /**
	     * 设置重复执行的次数
	     * @param {number} amount 重复次数
	     * @example tween.repeat(5)
	     * @memberof vf.gui.Tween
	     */
	    repeat(amount: number): this;
	    /**
	     * 设置每个重复执行过程的延迟时间，毫秒
	     * @param {number} amount 延迟值
	     * @example tween.reverseDelay(500)
	     * @memberof vf.gui.Tween
	     */
	    reverseDelay(amount: number): this;
	    /**
	     * 是否在重复执行中启用反向动画
	     * @param {boolean} state true启动
	     * @param {Function=} _easingReverse 反向时的Easing function
	     * @example tween.yoyo(true)
	     * @memberof vf.gui.Tween
	     */
	    yoyo(state?: boolean | Function, _easingReverse?: (k: number) => number): this;
	    /**
	     * 设置缓动函数
	     * @param {Function} _easingFunction 缓动函数的公式，如果设置yoyo的第二个值会应用于逆向缓动
	     * @example tween.easing(Easing.Elastic.InOut)
	     * @memberof vf.gui.Tween
	     */
	    easing(_easingFunction: ((k: number) => number) | any): this;
	    easingReverse(_easingReverse: ((k: number) => number) | any): this;
	    /**
	     * 设置差值
	     * @param {Function} _interpolationFunction 差值的函数
	     * @example tween.interpolation(Interpolation.Bezier)
	     * @memberof vf.gui.Tween
	     */
	    interpolation(_interpolationFunction: (v: any, k: number, value: any) => any): this;
	    /**
	     * 更新动画到指定时间点，进行播放
	     * @param time
	     */
	    gotoAndPlay(time: number): void;
	    /**
	     * 更新动画到指定时间点，停止播放
	     * @param time
	     */
	    gotoAndStop(time: number): void;
	    /**
	     * 更新动画到指定时间点，停止播放
	     * @param time
	     */
	    gotoAndEnd(): void;
	    /**
	     * 更新函数，通过给定的 `time` 设置目标属性变化
	    * @param {number=} deltaTime 帧间隔
	    * @param {Boolean=} preserve 完成后，防止删除动画对象
	     * @param {boolean=} forceTime 强制进行更新渲染，不关心时间是否匹配
	     * @example tween.update(100)
	     * @memberof vf.gui.Tween
	     */
	    update(deltaTime: number, preserve?: boolean, forceTime?: boolean): boolean;
	    release(): void;
	}

}
declare module 'src/core/Ticker' {
	 class Ticker extends vf.Ticker {
	    constructor();
	    start(): void;
	    currentTickerTime: number;
	    update(currentTime: number): void;
	    /**
	     * 时间穿越， 单位ms
	     * @param duration
	     */
	    timeTravel(duration: number): void;
	}
	export const TickerShared: Ticker;
	export {};

}
declare module 'src/tween/Timeline' {
	/**
	 * 基于帧的时间轴控制类
	    *
	 * @example let timeline = new vf.gui.Timeline();
	 *
	 */
	///   types="@vf.js/vf" />
	import { Tween } from 'src/tween/Tween';
	export class TimeLineDefaultData {
	    delay?: number;
	    paused?: boolean;
	    repeat?: number;
	    ease?: ((k: number) => number) | any;
	    yoyo?: boolean;
	    onStart?: Function;
	    onStartParams?: any;
	    onUpdate?: Function;
	    onUpdateParams?: any;
	    onRepeat?: Function;
	    onRepeatParams?: any;
	    onComplete?: Function;
	    onCompleteParams?: any;
	    onReverseComplete?: Function;
	    onReverseCompleteParams?: any;
	}
	export class TimeLineDataItem {
	    tween?: Tween;
	    positionTime: number;
	    hasPlay: boolean;
	}
	export class TimeLine extends vf.utils.EventEmitter {
	    private _defaultParam;
	    private _duration;
	    private _reactDuration;
	    private _objList;
	    private _propertyList;
	    private _tweens;
	    private _pauseTime;
	    private _pauseCallBack?;
	    private _pauseCallBackParam?;
	    private _currenTimer;
	    private _totalRepeat;
	    private _repeat;
	    private _playStates;
	    private _oldPlayStates;
	    private _tickIns;
	    private _isFinite;
	    private _needDownGrade;
	    constructor(options: TimeLineDefaultData);
	    set needDownGrade(value: boolean);
	    get needDownGrade(): boolean;
	    set onStart(value: any);
	    set onStartParams(value: any);
	    set onUpdate(value: any);
	    set onUpdateParams(value: any);
	    set onRepeat(value: any);
	    set onRepeatParams(value: any);
	    set onComplete(value: any);
	    set onCompleteParams(value: any);
	    set onReverseComplete(value: any);
	    set onReverseCompleteParams(value: any);
	    getDefaultParam(): any;
	    private set playStates(value);
	    get duration(): number;
	    get currenTimer(): number;
	    get reversed(): boolean;
	    get paused(): boolean;
	    /**
	     * 顺序播放
	     *
	     */
	    add(value: Tween, position?: number): this;
	    private cacheStartData;
	    private cacheStartDataTest;
	    private getNextValue;
	    private getPropertyList;
	    private toStartData;
	    /**
	     *
	     * 获取时刻数据
	     */
	    setTimeProries(timer: number): void;
	    /**
	     *
	     */
	    addPause(position?: number, callback?: Function, paranms?: any): this;
	    /**
	     * 相当于 add(TweenLite.to(...))
	     */
	    to(element: any, duration: number, options: any, position?: number): this;
	    /**
	     *
	     */
	    play(timer?: number): void;
	    /**
	     * 暂停
	     */
	    pause(): void;
	    /**
	     *
	     */
	    resume(): void;
	    /**
	     * 跳转
	     */
	    seek(timer: number): void;
	    /**
	     * 倒放
	     */
	    reverse(timer?: number): void;
	    /**
	     * 刷新
	     */
	    onUpdata(time: number): void;
	    private playUpdate;
	    private checkPause;
	    private tweenItemPlay;
	    private checkNextRepeat;
	    private checkTweensComplete;
	    private toNext;
	    private complete;
	    private stopAll;
	    release(): void;
	}

}
declare module 'src/tween/private/core' {
	import { Tween } from 'src/tween/Tween';
	import { TimeLine } from 'src/tween/Timeline';
	/**
	 * 插件存储器
	 * @memberof vf.gui.tween
	 * @example
	 * let num = Plugins.num = function (node, start, end) {
	  * return t => start + (end - start) * t
	  * }
	  *
	  * @static
	  */
	export const Plugins: any;
	/**
	 * 添加对象到缓动列表
	 * @param {Tween} tween Tween 实例
	 * @memberof vf.gui.tween
	 * @example
	 * let tween = new vf.gui.tween.Tween({x:0})
	 * tween.to({x:200}, 1000)
	 * vf.gui.tween.add(tween)
	 */
	export function add(tween: Tween): void;
	/**
	 * 没有缓动后，设置运行多少帧后，停止
	 * @param {number} frameCount=120 删除所有动画后，要运行的剩余帧
	 * @memberof vf.gui.tween
	 * @example
	 * vf.gui.tween.FrameThrottle(60)
	 */
	export function FrameThrottle(frameCount?: number): void;
	/**
	 * 延时处理，针对插件、canvas、dom
	 * @param {number} state=true 是否平滑处理
	 * @memberof vf.gui.tween
	 * @example
	 * vf.gui.tween.ToggleLagSmoothing(false)
	 */
	export function ToggleLagSmoothing(_state?: boolean): void;
	/**
	 * 获得所有缓动对象
	 * @memberof vf.gui.tween
	 * vf.gui.tween.getAll()
	 */
	export function getAll(): Tween[];
	/**
	 * 移除所有动画对象
	 * @example  vf.gui.tween.removeAll()
	 * @memberof vf.gui.tween
	 */
	export function removeAll(): void;
	/**
	 * 获取对象
	 * @param {Tween} tween 缓动对象实例
	 * @return {Tween} 返回对象或null
	 * @memberof vf.gui.tween
	 * @example
	 * vf.gui.tween.get(tween)
	 */
	export function get(tween: Tween): Tween | null;
	/**
	 * 从缓动列表移除对象
	 * @param {Tween} tween Tween instance
	 * @memberof vf.gui.tween
	 * @example
	 * vf.gui.tween.remove(tween)
	 */
	export function remove(tween: Tween): void;
	export function removeDisplay(uuid: string): void;
	/**
	 * 按给定时间更新缓动
	 * @param {number=} time 时间戳
	 * @param {Boolean=} preserve 完成后，防止删除动画对象
	 * @memberof vf.gui.tween
	 * @example
	 * vf.gui.tween.update(500)
	 */
	export function update(deltaTime: number): boolean;
	/**
	 * 是否正在运行中
	 * @return {Boolean} 只要还有缓动在运行，返回true
	 * @memberof vf.gui.tween
	 * @example vf.gui.tween.isRunning()
	 */
	export function isRunning(): boolean;
	/**
	 * 返回是否开启延迟平滑状态
	 * @return {Boolean}
	 * @memberof vf.gui.tween
	 * @example vf.gui.tween.isRunning()
	 */
	export function isLagSmoothing(): boolean;
	/**
	 * 添加到列表
	 */
	export function addTimeLine(timeLine: TimeLine): void;
	/**
	 * 移除列表
	 */
	export function removeTimeLine(timeLine: TimeLine): void;
	/**
	 * 销毁所有
	 */
	export function releaseAllTimeLine(): void;

}
declare module 'src/tween/private/index' {
	import { add, get, getAll, isRunning, FrameThrottle, ToggleLagSmoothing, Plugins, remove, removeAll, removeDisplay, update, addTimeLine, removeTimeLine, releaseAllTimeLine } from 'src/tween/private/core';
	import { Interpolation } from 'src/tween/private/Interpolation';
	import * as utils from 'src/tween/private/constants';
	import { TweenEvent } from 'src/event/TweenEvent';
	import { TimeLine } from 'src/tween/TimeLine';
	export { Plugins, get, getAll, removeAll, remove, removeDisplay, add, update, releaseAllTimeLine, addTimeLine, removeTimeLine, isRunning, FrameThrottle, ToggleLagSmoothing, Interpolation, TweenEvent, TimeLine, utils };

}
declare module 'src/core/DisplayLayoutKeys' {
	/** 标记属性失效 */
	export const invalidatePropertiesFlag: symbol;
	/** 标记大小失效 */
	export const invalidateSizeFlag: symbol;
	/** 标记显示失效 */
	export const invalidateDisplayListFlag: symbol;
	/** 是否参与布局 */
	export const includeInLayout: symbol;
	export const width: symbol;
	export const height: symbol;
	export const explicitWidth: symbol;
	export const explicitHeight: symbol;
	export const minWidth: symbol;
	export const maxWidth: symbol;
	export const minHeight: symbol;
	export const maxHeight: symbol;
	export const percentWidth: symbol;
	export const percentHeight: symbol;
	export const measuredWidth: symbol;
	export const measuredHeight: symbol;
	export const oldPreferWidth: symbol;
	export const oldPreferHeight: symbol;
	export const left: symbol;
	export const right: symbol;
	export const top: symbol;
	export const bottom: symbol;
	export const horizontalCenter: symbol;
	export const verticalCenter: symbol;

}
declare module 'src/core/DisplayLayoutValidator' {
	///   types="@vf.js/vf" />
	import { DisplayLayoutAbstract } from 'src/core/DisplayLayoutAbstract'; class UIValidator extends vf.utils.EventEmitter {
	    /**
	     * @private
	     * 创建一个Validator对象
	     */
	    constructor();
	    /**
	     * @private
	     */
	    private targetLevel;
	    /**
	     * @private
	     */
	    private invalidatePropertiesFlag;
	    /**
	     * @private
	     */
	    private invalidateClientPropertiesFlag;
	    /**
	     * @private
	     */
	    private invalidatePropertiesQueue;
	    /**
	     * @private
	     * 标记组件属性失效
	     */
	    invalidateProperties(target: DisplayLayoutAbstract): void;
	    /**
	     * @private
	     * 验证失效的属性
	     */
	    private validateProperties;
	    /**
	     * @private
	     */
	    private invalidateSizeFlag;
	    /**
	     * @private
	     */
	    private invalidateClientSizeFlag;
	    /**
	     * @private
	     */
	    private invalidateSizeQueue;
	    /**
	     * @private
	     * 标记需要重新测量尺寸
	     */
	    invalidateSize(target: DisplayLayoutAbstract): void;
	    /**
	     * @private
	     * 测量尺寸
	     */
	    private validateSize;
	    /**
	     * @private
	     */
	    private invalidateDisplayListFlag;
	    /**
	     * @private
	     */
	    private invalidateDisplayListQueue;
	    /**
	     * @private
	     * 标记需要重新布局
	     */
	    invalidateDisplayList(client: DisplayLayoutAbstract): void;
	    /**
	     * @private
	     * 重新布局
	     */
	    private validateDisplayList;
	    /**
	     * @private
	     * 是否已经添加了事件监听
	     */
	    private listenersAttached;
	    /**
	     * @private
	     * 添加事件监听
	     */
	    private attachListeners;
	    /**
	     * @private
	     * 执行属性应用
	     */
	    private doPhasedInstantiationCallBack;
	    /**
	     * @private
	     */
	    private doPhasedInstantiation;
	    /**
	     * @private
	     * 使大于等于指定组件层级的元素立即应用属性
	     * @param target 要立即应用属性的组件
	     */
	    validateClient(target: DisplayLayoutAbstract): void;
	    removeDepthQueueAll(): void;
	} const validatorShared: UIValidator;
	export default validatorShared;

}
declare module 'src/core/ContainerBase' {
	///   types="@vf.js/vf" />
	/** 容器扩展类，后续便于做延时渲染 */
	export class ContainerBase extends vf.Container {
	    constructor();
	    isEmitRender: boolean;
	    render(renderer: vf.Renderer): void;
	}

}
declare module 'src/core/plugs/LineGradient' {
	///   types="@vf.js/vf" />
	interface TextureFillParamType {
	    canvas?: HTMLCanvasElement;
	    context?: CanvasRenderingContext2D;
	    texture?: vf.Texture;
	    width: number;
	    height: number;
	    anchorX: number;
	    anchorY: number;
	    style: {
	        fillColor: number[] | number[][];
	        fillGradientStops: number[];
	        fillGradientType: 0 | 1;
	    };
	}
	/**
	 * 设置渐变
	 * @param type
	 * @param stops
	 * @param color
	 * @returns
	 */
	export function updateTextureFill(_display: vf.Graphics, fillParam: TextureFillParamType): TextureFillParamType | undefined;
	export {};

}
declare module 'src/core/Background' {
	export class Background {
	    constructor(parent: any);
	    private canvas?;
	    private context?;
	    private texture?;
	    private parent;
	    private _container?;
	    private _oldSrc;
	    private _oldRepeat;
	    private _rect?;
	    private _image?;
	    private _mask?;
	    private _invalidateFlag;
	    isInit: boolean;
	    private _type;
	    get type(): 0 | 1 | 2;
	    set type(value: 0 | 1 | 2);
	    private _color;
	    get color(): number | undefined;
	    set color(value: number | undefined);
	    private _alpha;
	    get alpha(): number;
	    set alpha(value: number);
	    private _radius;
	    get radius(): number;
	    set radius(value: number);
	    private _src;
	    get src(): string | undefined;
	    set src(value: string | undefined);
	    private _positionX;
	    get positionX(): number;
	    set positionX(value: number);
	    private _positionY;
	    get positionY(): number;
	    set positionY(value: number);
	    private _size;
	    get size(): number[] | undefined;
	    set size(value: number[] | undefined);
	    private _repeat;
	    get repeat(): "no-repeat" | "repeat";
	    set repeat(value: "no-repeat" | "repeat");
	    private _fillAlpha;
	    get fillColor(): number | undefined;
	    set fillColor(value: number | undefined);
	    private _fillGradientStops;
	    get fillGradientStops(): number[];
	    set fillGradientStops(value: number[]);
	    private _fillGradientType;
	    get fillGradientType(): 0 | 1;
	    set fillGradientType(value: 0 | 1);
	    private lastW?;
	    private lastH?;
	    update(w: number, h: number): void;
	    private drawRect;
	    private removeImage;
	    release(): void;
	}

}
declare module 'src/core/MaskSprite' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	export interface MaskSprite extends DisplayObject {
	    maskSprite(): vf.Sprite | vf.Graphics;
	}

}
declare module 'src/core/Mask' {
	///   types="@vf.js/vf" />
	import { MaskSprite } from 'src/core/MaskSprite';
	export class Mask {
	    constructor(parent: any);
	    private parent;
	    private _image?;
	    private _oldImage;
	    private _mask;
	    private _invalidateFlag;
	    private _position?;
	    get position(): number[] | undefined;
	    set position(value: number[] | undefined);
	    private _size;
	    get size(): number[] | undefined;
	    set size(value: number[] | undefined);
	    get image(): string | vf.Graphics | MaskSprite | undefined;
	    set image(value: string | vf.Graphics | MaskSprite | undefined);
	    update(w: number, h: number): void;
	    private getGuiObject;
	    release(): void;
	}

}
declare module 'src/core/DisplayObjectAbstract' {
	///   types="@vf.js/vf" />
	import { ContainerBase } from 'src/core/ContainerBase';
	import { Stage } from 'src/core/Stage';
	import { DisplayObject } from 'src/core/DisplayObject';
	import { Background } from 'src/core/Background';
	import { Mask } from 'src/core/Mask';
	export class DisplayObjectAbstract extends vf.utils.EventEmitter implements LifecycleHook, Lifecycle {
	    constructor();
	    /**
	     * 全局唯一ID
	     */
	    readonly uuid: number;
	    id: string;
	    /**
	     * 自定义组价名
	     */
	    name: string;
	    /**
	     * @private
	     * 这个对象在显示列表中的嵌套深度，舞台为1，它的子项为2，子项的子项为3，以此类推。当对象不在显示列表中时此属性值为0.
	     */
	    $nestLevel: number;
	    /**
	     * 是否初始化
	     * @default
	     */
	    initialized: boolean;
	    /**
	     * 舞台引用
	     */
	    $stage?: Stage;
	    /**
	     * 父容器
	     */
	    parent: DisplayObject | Stage | undefined;
	    /**
	     * 节点列表
	     */
	    uiChildren: DisplayObjectAbstract[];
	    /** 没有功能实现，内部编辑器 */
	    container: ContainerBase;
	    /**
	     * 背景(内部使用)
	     */
	    $background: Background;
	    /**
	     * 遮罩(内部使用)，设置遮罩后，组件内部的索引位置可能产生变化
	     */
	    $mask: Mask;
	    /**
	     * 是否开启事件同步
	     */
	    syncabled: boolean;
	    /**
	     * 是否开启恢复时派发事件
	     */
	    resumeabled: boolean;
	    /** 添加显示对象，需集成Core */
	    addChild<T extends DisplayObjectAbstract>(item: T): T;
	    /**
	     * 插入显示对象到特定位置
	     * @param item 显示对象
	     * @param index 要插入的索引，最大值为当前显示列表的长度，最小值为0
	     */
	    addChildAt<T extends DisplayObjectAbstract>(item: T, index: number): T;
	    getChildAt(index: number): DisplayObjectAbstract;
	    getChildByUUID(uuid: number): DisplayObjectAbstract | undefined;
	    _getChildById(id: string): DisplayObjectAbstract | undefined;
	    getChildByPath(ids: string[]): DisplayObjectAbstract | undefined;
	    /**
	     * 移除已添加的UI组件
	     * @param UIObject 要移除的UI组件
	     */
	    removeChild<T extends DisplayObjectAbstract>(item: T): T;
	    removeChildAt<T>(index: number): T;
	    /**
	     * 移除元素
	     * @param release 是否释放子节点，破坏结构
	     * @param beginIndex 开始
	     * @param endIndex 结束
	     */
	    removeChildren(release?: boolean, beginIndex?: number | undefined, endIndex?: number | undefined): void;
	    /**
	     * 是否绘制显示对象，如果false不进行绘制，不过仍然会进行相关的更新计算。
	     * 只影响父级的递归调用。
	     */
	    set renderable(value: boolean);
	    get renderable(): boolean;
	    private _interactive;
	    /**
	     * 对象是否可以接收事件
	     */
	    set interactive(value: boolean);
	    get interactive(): boolean;
	    private _interactiveChildren;
	    /**
	     * 子对象是否可以接收事件，设置false后，会绕过HitTest方法的递归
	     */
	    set interactiveChildren(value: boolean);
	    get interactiveChildren(): boolean;
	    /**
	     * 子类实现
	     */
	    validateNow(): void;
	    private _enabled;
	    get enabled(): boolean;
	    set enabled(value: boolean);
	    /**
	     * 是否可见
	     */
	    private _visible;
	    get visible(): boolean;
	    set visible(value: boolean);
	    /** 清除全部事件 */
	    offAll(event?: string | symbol): this;
	    get stage(): Stage | undefined;
	    protected checkInvalidateFlag(): void;
	    load(): void;
	    release(): void;
	    $onInit(): void;
	    $onLoad(): void;
	    $onRelease(): void;
	    $onAddStage(): void;
	    $onRemoveStage(): void;
	}

}
declare module 'src/core/DisplayLayoutAbstract' {
	///   types="@vf.js/vf" />
	import { DisplayObjectAbstract } from 'src/core/DisplayObjectAbstract';
	export const $tempLocalBounds: vf.Rectangle;
	/**
	 * UI 布局的基础属性类
	 */
	export class DisplayLayoutAbstract extends DisplayObjectAbstract {
	    constructor();
	    isContainer: boolean;
	    /**
	     * @private
	     */
	    $values: any;
	    /**
	     * @private
	     * 定义的所有变量请不要添加任何初始值，必须统一在此处初始化。
	     */
	    protected initializeUIValues(): void;
	    /**
	     * @private
	     * 检查属性失效标记并应用
	     */
	    protected checkInvalidateFlag(): void;
	    /**
	     * @private
	     * 验证组件的属性
	     */
	    validateProperties(): void;
	    /**
	     * @private
	     * 验证组件的尺寸
	     */
	    validateSize(recursive?: boolean): void;
	    /**
	     * @private
	     * 验证子项的位置和大小，并绘制其他可视内容
	     */
	    validateDisplayList(): void;
	    /**
	     * @private
	     * 提交属性，子类在调用完invalidateProperties()方法后，应覆盖此方法以应用属性
	     */
	    protected commitProperties(): void;
	    /**
	     * 测量显示对象宽高，如果子类没有重写，默认是this.container.width..
	     */
	    protected measure(): void;
	    /**
	     * @private
	     * 测量组件尺寸，返回尺寸是否发生变化
	     */
	    protected measureSizes(): boolean;
	    /**
	     * @private
	     *
	     * @returns
	     */
	    protected getPreferredUWidth(): number;
	    /**
	     * @private
	     */
	    protected getPreferredUHeight(): number;
	    /**
	     * @private
	     * 获取组件的首选尺寸,常用于父级的measure()方法中
	     * 按照：外部显式设置尺寸>测量尺寸 的优先级顺序返回尺寸，
	     */
	    getPreferredBounds(bounds: vf.Rectangle): vf.Rectangle;
	    /**
	    * @private
	    * 标记提交过需要延迟应用的属性，以便在稍后屏幕更新期间调用该组件的 commitProperties() 方法。
	    *
	    * 例如，要更改文本颜色和大小，如果在更改颜色后立即进行更新，然后在设置大小后再更新大小，就有些浪费。
	    * 同时更改两个属性后再使用新的大小和颜色一次性呈示文本，效率会更高。<p/>
	    *
	    * 通常，子类应覆盖 commitProperties() 方法，而不是覆盖此方法。
	     */
	    invalidateProperties(): void;
	    /**
	    * @private
	    * 标记提交过需要验证组件尺寸，以便在稍后屏幕更新期间调用该组件的 measure(),updatesize() 方法。
	    */
	    invalidateSize(): void;
	    /**
	    * @private
	    * 标记需要验证显示列表，以便在稍后屏幕更新期间调用该组件的 updateDisplayList() 方法。
	    */
	    invalidateDisplayList(): void;
	    /**
	     * @private
	     * 标记父级容器的尺寸和显示列表为失效
	     */
	    invalidateParentLayout(): void;
	    /**
	     * @private
	     * 设置组件的布局位置
	     */
	    setPosition(x?: number | undefined, y?: number | undefined): void;
	    /**
	     * @private
	     * 设置测量结果。
	     * @param width 测量宽度
	     * @param height 测量高度
	     */
	    setMeasuredSize(width: number, height: number): void;
	    /**
	     * @private
	     * 设置组件的宽高。此方法不同于直接设置width,height属性，
	     * 不会影响显式标记尺寸属性
	     */
	    setActualSize(w: number, h: number, isInvalidate?: boolean): void;
	    updateTransform(): void;
	    /**
	     * 更新背景
	     */
	    protected updateBackground(unscaledWidth: number, unscaledHeight: number): void;
	    /**
	     * 更新遮罩
	     */
	    protected updateMask(unscaledWidth: number, unscaledHeight: number): void;
	    /**
	     * @private
	     * 更新最终的组件宽高
	     */
	    protected updateSize(): void;
	    /**
	     * 更新显示列表,子类重写，实现布局
	     */
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    /**
	     * @private
	     * 立即应用组件及其子项的所有属性
	     */
	    validateNow(): void;
	    /**
	     * @private
	    * 验证并更新此对象的属性和布局，如果需要的话重绘对象。
	    *
	    * 通常只有当脚本执行完毕后，才会处理要求进行大量计算的处理属性。<p/>
	    *
	    * 例如，对 width 属性的设置可能会延迟，因为此设置需要重新计算这些对象的子项或父项的宽度。
	    * 如果脚本多次设置了 width 属性，则延迟处理可防止进行多次处理。此方法允许您手动覆盖此行为。
	     */
	    validateSizeNow(): void;
	    /**
	     * 指定此组件是否包含在父容器的布局中。若为false，则父级容器在测量和布局阶段都忽略此组件。默认值为true。
	     * 注意，visible属性与此属性不同，设置visible为false，父级容器仍会对其布局。
	     */
	    get includeInLayout(): boolean;
	    set includeInLayout(value: boolean);
	    /**
	     * @private
	     * 距父级容器离左边距离
	     */
	    get left(): any;
	    set left(value: any);
	    /**
	     * @private
	     * 距父级容器右边距离
	     */
	    get right(): any;
	    set right(value: any);
	    /**
	     * @private
	     * 距父级容器顶部距离
	     */
	    get top(): any;
	    set top(value: any);
	    /**
	     * @private
	     * 距父级容器底部距离
	     */
	    get bottom(): any;
	    set bottom(value: any);
	    /**
	     * @private
	     * 在父级容器中距水平中心位置的距离
	     */
	    get horizontalCenter(): any;
	    set horizontalCenter(value: any);
	    /**
	     * @private
	     * 在父级容器中距竖直中心位置的距离
	     */
	    get verticalCenter(): any;
	    set verticalCenter(value: any);
	    /**
	     * @private
	     * 相对父级容器宽度的百分比
	     */
	    get percentWidth(): number;
	    set percentWidth(value: number);
	    /**
	     * @private
	     * 相对父级容器高度的百分比
	     */
	    get percentHeight(): number;
	    set percentHeight(value: number);
	    /**
	     * @private
	     * 外部显式指定的宽度
	     */
	    get explicitWidth(): number;
	    /**
	     * @private
	     * 外部显式指定的高度
	     */
	    get explicitHeight(): number;
	    /**
	     * @private
	     * 组件的最小宽度,此属性设置为大于maxWidth的值时无效。同时影响测量和自动布局的尺寸。
	     */
	    get minWidth(): number;
	    set minWidth(value: number);
	    /**
	     * @private
	     * 组件的最大高度。同时影响测量和自动布局的尺寸。
	     */
	    get maxWidth(): number;
	    set maxWidth(value: number);
	    /**
	     * @private
	     * 组件的最小高度,此属性设置为大于maxHeight的值时无效。同时影响测量和自动布局的尺寸。
	     */
	    get minHeight(): number;
	    set minHeight(value: number);
	    /**
	     * @private
	     * 组件的最大高度,同时影响测量和自动布局的尺寸。
	     */
	    get maxHeight(): number;
	    set maxHeight(value: number);
	    allInvalidate(): void;
	    /**
	     * @private
	     * 组件宽度设置为undefined将使用组件的measure()方法自动计算尺寸
	     */
	    get width(): number;
	    /**
	     * @private
	     *
	     * @param value
	     */
	    set width(value: number);
	    /**
	     * @private
	     * 组件高度,默认值为NaN,设置为NaN将使用组件的measure()方法自动计算尺寸
	     */
	    get height(): number;
	    /**
	     * @private
	     *
	     * @param value
	     */
	    set height(value: number);
	    get scaleX(): number;
	    set scaleX(value: number);
	    get scaleY(): number;
	    set scaleY(value: number);
	    get x(): number;
	    set x(value: number);
	    get y(): number;
	    set y(value: number);
	    get skewX(): number;
	    set skewX(value: number);
	    get skewY(): number;
	    set skewY(value: number);
	    get pivotX(): number;
	    set pivotX(value: number);
	    get pivotY(): number;
	    set pivotY(value: number);
	    get rotation(): number;
	    set rotation(value: number);
	    /**
	     *  =不可用= 设置索引层级，每次父级变化时，会排序 （未实现）
	     */
	    get zIndex(): number;
	    set zIndex(value: number);
	}

}
declare module 'src/event/EventType' {
	export const enum EventType {
	    /**
	     * 状态变化 ：IVFData -> VFStateCode
	     */
	    STATUS = "status",
	    /**
	     * 推送消息到外部
	     */
	    MESSAGE = "message",
	    /**
	     * 接收外部消息
	     */
	    ONMESSAGE = "onMessage",
	    /**
	     * 通用状态变化
	     */
	    STATE = "state",
	    /**
	     * 启动/开始
	     */
	    START = "start",
	    /**
	     * 心跳
	     */
	    TICK = "tick",
	    /**
	     * 更新
	     */
	    UPDATE = "update",
	    /**
	     * 已改变
	     */
	    CHANGED = "changed",
	    /**
	     * 结束
	     */
	    END = "end"
	}

}
declare module 'src/event/EventLevel' {
	/**
	 * status: 状态变化
	 *
	 * command: 执行操作
	 *
	 * ----------------------
	 *
	 * Info: 默认的等级
	 *
	 * Warn: 表示可能对系统有损害的情况
	 *
	 * 表示非常严重的错误等级，记录极有可能导致应用程序终止运行的致命错误信息；
	 */
	export const enum EventLevel {
	    /**
	     * 状态
	     */
	    STATUS = "status",
	    /**
	     * 命令
	     */
	    COMMAND = "command",
	    /**
	     * 默认的等级
	     */
	    INFO = "info",
	    /**
	     * 警告
	     */
	    WARNING = "warning",
	    /**
	     * 错误
	     */
	    ERROR = "error",
	    /**
	     * 原生
	     */
	    NATIVE = "native"
	}

}
declare module 'src/core/Scheduler' {
	///   types="@vf.js/vf" />
	/**
	 * Schedule anything
	 *
	 * @author 8088
	 */
	export class Scheduler extends vf.utils.EventEmitter {
	    get id(): number;
	    static schedulerList: Scheduler[];
	    static stopAll(): void;
	    static setEnterFrame(listener: (data?: any) => void): Scheduler;
	    static setInterval(time: number, listener: (data?: any) => void): Scheduler;
	    static setTimeout(time: number, listener: (data?: any) => void): Scheduler;
	    _interval: number;
	    _timeout: number;
	    private _id;
	    private _running;
	    private _pausing;
	    private _totalDuration;
	    private _intervalDuration;
	    constructor(timeout?: number, interval?: number);
	    restart(): void;
	    stop(): void;
	    pause(): void;
	    resume(): void;
	    private run;
	}

}
declare module 'src/core/Stage' {
	///   types="@vf.js/vf" />
	import { DisplayLayoutAbstract } from 'src/core/DisplayLayoutAbstract';
	import { SyncManager } from 'src/interaction/SyncManager';
	/**
	 * UI的舞台对象，展示所有UI组件
	 *
	 * @class
	 * @param width {Number} 舞台宽度
	 * @param height {Number} 舞台高度
	 */
	export class Stage extends DisplayLayoutAbstract {
	    constructor(width: number, height: number, app: vf.Application);
	    app: vf.Application;
	    syncManager: SyncManager | undefined;
	    resumeStatusFlag: boolean;
	    /**
	     * 是否组织原始数据继续传递
	     */
	    originalEventPreventDefault: boolean;
	    get stageWidth(): number;
	    get stageHeight(): number;
	    get scaleX(): number;
	    set scaleX(value: number);
	    get scaleY(): number;
	    set scaleY(value: number);
	    set Scale(value: vf.Point);
	    /**
	     * 是否同步交互事件
	     */
	    private _syncInteractiveFlag;
	    set syncInteractiveFlag(value: boolean);
	    get syncInteractiveFlag(): boolean;
	    getSystemEvent(): vf.utils.EventEmitter;
	    sendToPlayer(e: any): void;
	    release(): void;
	    releaseAll(): void;
	    resize(): void;
	    /**
	     * 接收来自player的消息
	     * @param msg
	     */
	    receiveFromPlayer(msg: any): void;
	    /**
	     * 截图功能
	     */
	    private _virCanvas;
	    private getVitualCanvas;
	    screenShots(x: number, y: number, width: number, height: number, endWidth?: number, endHeight?: number, displayObject?: vf.DisplayObject): vf.Texture;
	}

}
declare module 'src/enum/FollowLineEnum' {
	export const enum Role {
	    /** 老师 */
	    teacher = "T",
	    /** 学生 */
	    student = "S"
	}
	export const enum Operate {
	    add = "1",
	    remove = "2",
	    clear = "3"
	}

}
declare module 'src/interaction/SyncManager' {
	/**
	 * 用于同步输入事件
	 * by ziye
	 */
	///   types="@vf.js/vf" />
	import { InteractionEvent } from 'src/event/InteractionEvent';
	import { Stage } from 'src/core/Stage';
	import { DisplayObjectAbstract } from 'src/core/DisplayObjectAbstract';
	import { Role } from 'src/enum/FollowLineEnum';
	export class SyncManager extends vf.utils.EventEmitter {
	    constructor(stage: Stage);
	    /**
	     * 对应一个stage有一个syncManager的实例
	     */
	    static getInstance(stage?: Stage | undefined): SyncManager | undefined;
	    static getIns(): SyncManager | undefined;
	    static instance?: SyncManager;
	    private _role;
	    mode: number;
	    resumeStatusFlag: boolean;
	    resumeImmediately: boolean;
	    offsetTime: number;
	    private _initTime;
	    private _interactionEvent;
	    private _stage;
	    private _lostMoveEvent;
	    private _throttleMoveFlag;
	    private _throttleMoveTimer;
	    private _evtDataList;
	    private _readystate;
	    private _sendId;
	    private _lastSId;
	    private _lastTId;
	    private _lastSEventData;
	    private _lastTEventData;
	    private _swaitingEventList;
	    private _twaitingEventList;
	    private _waitTimer;
	    private _resumeTimer;
	    private _heartTimer;
	    private _autoHeartTimer;
	    autoHeartFlag: any;
	    _initDataTimer: number;
	    initDataFlag: boolean;
	    private _resumeStoreList;
	    private _startFlag;
	    private _lostEvent;
	    private _throttleEventTimer;
	    private _lastEventData?;
	    /**
	     * log
	     */
	    private log;
	    /**
	     * 清理syncManager
	     */
	    stop(): void;
	    /**
	     * 开始同步
	     */
	    start(): void;
	    /**
	     * 重置syncManager
	     */
	    private reset;
	    /**
	     * 角色
	     */
	    set role(value: Role);
	    get role(): Role;
	    /**
	     * 自动心跳，自动心跳基于每次输入操作之后，心跳10次，间隔0.5
	     * @param duration
	     * @param role
	     */
	    private autoHeartEvent;
	    /**
	     * 同步心跳
	     * @duration 心跳间隔
	     * @role 1-老师  2-学生   12-老师学生均发心跳
	     */
	    syncHeartEvent(duration: number, role?: number): void;
	    /**
	     * 发送心跳
	     */
	    sendHeartEvent(): void;
	    /**
	     * 收集交互事件
	     */
	    collectEvent(e: InteractionEvent, obj: DisplayObjectAbstract): void;
	    /**
	     * 发送自定义事件
	     * customData 自定义数据
	     */
	    sendCustomEvent(customData: any): void;
	    /**
	     * 发送当前时间
	     */
	    private sendSyncTimeEvent;
	    /**
	     * 接收操作
	     * @signalType 信令类型  live-实时信令   history-历史信令
	     */
	    receiveEvent(eventData: any, signalType?: string): void;
	    private dealLiveEvent;
	    /**
	     * 检查eventId是否正确
	     */
	    private checkEventId;
	    /**
	     * 检查是否有暂存的event需要执行
	     * forceFlag: 是否强制执行
	     */
	    private checkWaitingEvent;
	    /**
	     * 获取当前时间
	     */
	    private currentTime;
	    /**
	     * 构造一个新的e，用于同步，数据要尽量精简
	     */
	    private createEventData;
	    /**
	     * 发送操作(稀疏前的每一次单条发送)
	     */
	    private sendEvent;
	    /**
	     * 智能检测，如果是end，把所有暂存的一起立即发送
	     * 如果是start的，暂存起来，启动300ms的定时
	     * 如果是其他的，已经有暂存，则将继续暂存，否则立即发送
	     * @param eventData
	     */
	    private checkEventData;
	    private dealLostEvent;
	    /**
	     * 真实发送(稀疏后的真实发送，可能是单条，可能是数组)
	     */
	    private realSendEvent;
	    /**
	     * 更新节流状态
	     */
	    private throttleUpdate;
	    /**
	     * 节流，每100ms发送一次
	     * @param eventData
	     */
	    private throttle;
	    private resetStage;
	    /**
	     * 解析收到的event
	     */
	    private parseEventData;
	    /**
	     * 时间未到，需要穿越到未来
	     */
	    private timeTravel;
	    /**
	     * 模板初始化
	     * @param history
	     */
	    private initData;
	    /**
	     * 处理历史信令，将历史输入事件按时间顺序放置到一个数组
	     * @param eventData
	     */
	    private dealHistoryEvent;
	    private resumeStatusImmediately;
	    /**
	     * 恢复状态
	     */
	    private resumeStatus;
	    private resetCallback;
	}

}
declare module 'src/interaction/ClickEvent' {
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 * 点击触摸相关的事件处理订阅类,UI组件内部可以创建此类实现点击相关操作
	 *
	 *  可侦听事件:
	 * ```
	 *  {InteractionEvent}.TouchEvent.onHover
	 *  {InteractionEvent}.TouchEvent.onPress
	 *  {InteractionEvent}.TouchEvent.onClick
	 *  {InteractionEvent}.TouchEvent.onMove
	 * ```
	 *
	 * @example 可查看 `TestSliceSprite` 示例
	 *
	 * @since 1.0.0
	 */
	export class ClickEvent {
	    /**
	     * ClickEvent 构造函数
	     * @param obj 调用的显示对象
	     * @param includeHover 是否监听鼠标移上与移出，默认true
	     * @param rightMouseButton 是否开启鼠标右键点击，默认false
	     * @param doubleClick 是否开启鼠标双击,默认false
	     */
	    constructor(obj: DisplayObject, includeHover?: boolean, rightMouseButton?: boolean, doubleClick?: boolean);
	    /** 当前按下状态的所有对象，为了弹起统一做处理 */
	    private static downObjects;
	    private obj;
	    id: number;
	    /** 是否开启本地坐标转换，开启后，事件InteractionEvent中的localX localY为本地坐标，false情况下为0 */
	    isOpenLocalPoint: boolean;
	    private localOffset;
	    private offset;
	    private movementX;
	    private movementY;
	    private ishover;
	    private mouse;
	    private bound;
	    private right;
	    private hover;
	    double: boolean;
	    private time;
	    private isStop;
	    private deviceType;
	    getTarget(): DisplayObject;
	    startEvent(): void;
	    private _onStageTouchOutside;
	    private _onMouseRight;
	    /** 清除拖动 */
	    stopEvent(): void;
	    private _onMouseDown;
	    private emitTouchEvent;
	    private _mouseUpAll;
	    private _onMouseUp;
	    private _onMouseUpOutside;
	    private _onMouseOver;
	    private _onMouseOut;
	    private _tempMovePoint;
	    private _onMouseMove;
	    private setLocalPoint;
	    private removeAllMove;
	    remove(): void;
	}

}
declare module 'src/interaction/DragDropController' {
	import { DisplayObject } from 'src/core/DisplayObject';
	import { InteractionEvent } from 'src/event/InteractionEvent';
	/**
	 * 记录当前正在拖动的UI组件列表
	 * @private
	 */
	export const _items: DisplayObject[];
	export const _dropTargets: any[];
	/**
	 * 添加拖动组件到控制器
	 * @param item 要添加的UI组件
	 * @param e 传送的事件
	 * @returns true|false
	 * @since 1.0.0
	 */
	export function add(item: DisplayObject, e: InteractionEvent): boolean;
	export function remove(item: DisplayObject): boolean;
	/**
	 * 添加掉落容器
	 * @param group
	 * @param target
	 */
	export function addDropTarget(group: string, target: DisplayObject): void;
	/**
	 * 获取对应的掉落容器
	 * @param group
	 */
	export function getDropTargets(group: string): DisplayObject[];
	export function removeDropTarget(target: DisplayObject): void;
	/**
	 * 获取正在拖动组件
	 * @param item 要获取的UI组件
	 * @returns flase | item
	 */
	export function getItem(item: DisplayObject): false | DisplayObject;
	/**
	 * 根据事件对象与分组名获取拖动项
	 * @param e 事件对象
	 * @param group 分组名
	 */
	export function getEventItem(e: InteractionEvent, group: string | undefined): false | DisplayObject | null;

}
declare module 'src/interaction/DragEvent' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { InteractionEvent } from 'src/event/InteractionEvent';
	/**
	 * 多拽相关的事件处理类
	 *
	 *  可侦听事件:
	 * ```
	 *  {InteractionEvent}.DraggableEvent.onDragPress
	 *  {InteractionEvent}.DraggableEvent.onDragStart
	 *  {InteractionEvent}.DraggableEvent.onDragMove
	 *  {InteractionEvent}.DraggableEvent.onDragEnd
	 * ```
	 *  可赋值方法:
	 * ```
	 * onPress: ((e: InteractionEvent, isPressed: boolean,dragObj?: DragEvent) => void) | undefined;
	 * onDragEnd: ((e: InteractionEvent,dragObj?: DragEvent) => void) | undefined
	 * onDragMove: ((e: InteractionEvent, offset: vf.Point,dragObj?: DragEvent) => void) | undefined
	 * onDragStart: ((e: InteractionEvent,dragObj?: DragEvent) => void) | undefined
	 * ```
	 *
	 * @example 可查看 `Slider` 源码
	 *
	 * @since 1.0.0
	 */
	export class DragEvent {
	    constructor(obj: DisplayObject);
	    private obj;
	    id: number;
	    private offset;
	    private movementX;
	    private movementY;
	    private bound;
	    start: vf.Point;
	    private mouse;
	    private cancel;
	    private dragging;
	    private isStop;
	    private ishover;
	    /**
	     * 限制拖动抽,XY,X抽或Y抽
	     */
	    dragRestrictAxis?: "x" | "y";
	    startEvent(): void;
	    executeAction(e: InteractionEvent): void;
	    private _onDragOver;
	    private _onMouseOut;
	    private _onDragStart;
	    private _onDragMove;
	    private _onDragEnd;
	    /** 清除拖动 */
	    stopEvent(): void;
	    remove(): void;
	    onDragPress: ((e: InteractionEvent, isPressed: boolean, dragObj?: DragEvent) => void) | undefined;
	    onDragEnd: ((e: InteractionEvent, dragObj?: DragEvent) => void) | undefined;
	    onDragMove: ((e: InteractionEvent, offset: vf.Point, dragObj?: DragEvent) => void) | undefined;
	    onDragStart: ((e: InteractionEvent, dragObj?: DragEvent) => void) | undefined;
	    onDragHover: ((e: InteractionEvent, isHover: boolean, dragObj?: DragEvent) => void) | undefined;
	}

}
declare module 'src/display/Label' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 * 文本
	 *
	 * 中文换行特殊处理 xxxx.style.breakWords = true;
	 *
	 * 当文本容器设置宽高后，文字默认会根据文本容器宽高居中.
	 *
	 * 当文本容器设置宽高后，可通过 style.textAlign 进行文字位置调整
	 *
	 * @example let label = new vf.gui.Label();
	 *
	 */
	export class Label extends DisplayObject {
	    readonly sprite: vf.Text;
	    private _lineGraphics;
	    private _textDecorationWidth;
	    private _textDecorationStyle;
	    private _textAlpha;
	    private readonly _defaultColor;
	    private _color?;
	    constructor(text?: string);
	    private get widthNoShadow();
	    private get heightNoShadow();
	    private onWidthChange;
	    /**
	     * 设置分辨力比例
	     */
	    get resolution(): number;
	    set resolution(value: number);
	    get fillColor(): number[] | number[][];
	    set fillColor(value: number[] | number[][]);
	    set fillAlpha(value: number);
	    /**
	     * 文本颜色
	     */
	    get color(): string | number | number[] | string[] | undefined;
	    set color(value: string | number | number[] | string[] | undefined);
	    /**
	     * 文字透明度
	     */
	    get textAlpha(): number;
	    set textAlpha(value: number);
	    get textDecorationStyle(): 'Solid' | 'Double';
	    set textDecorationStyle(value: 'Solid' | 'Double');
	    /**
	     * 文本内容
	     */
	    get text(): string;
	    set text(value: string);
	    set fontCssStyle(value: any);
	    private setLine;
	    private showUnderLine;
	    private autoDrawLine;
	    private getStartPosX;
	    private getStartPosY;
	    private drawLine;
	    /**
	     * 测量显示对象宽高，如果子类没有重写，默认是this.container.width..
	     */
	    protected measure(): void;
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    private cacheOldData;
	    private clearLineGraphics;
	    release(): void;
	}

}
declare module 'src/utils/GifReader' {
	export class GifReader {
	    private _width;
	    private _height;
	    private _frames;
	    private _loop_count;
	    private _buf;
	    constructor(arrayBuffer: ArrayBuffer);
	    get width(): number;
	    get height(): number;
	    get numFrames(): number;
	    get loopCount(): number;
	    getFrameInfo(frame_num: number): FrameInfo;
	    decodeAndBlitFrameBGRA(frame_num: number, pixels: Uint8ClampedArray): FrameInfo;
	    decodeAndBlitFrameRGBA(frame_num: number, pixels: Uint8ClampedArray): FrameInfo;
	}
	export interface FrameInfo {
	    x: number;
	    y: number;
	    width: number;
	    height: number;
	    has_local_palette: boolean;
	    palette_offset: number;
	    palette_size: number;
	    data_offset: number;
	    data_length: number;
	    transparent_index: number;
	    interlaced: boolean;
	    delay: number;
	    disposal: number;
	}

}
declare module 'src/utils/GifFrames' {
	///   types="@vf.js/vf" />
	import { GifReader } from 'src/utils/GifReader';
	export class GifFrames {
	    private _frames;
	    private _gif;
	    constructor(_resource: vf.LoaderResource | ArrayBuffer);
	    private calcSingleTextureWidth;
	    get gif(): GifReader;
	    get frames(): Array<GifFrame>;
	    private generateTextureFromGifData;
	    get numFrames(): number;
	    getFrame(index: number): GifFrame;
	}
	export class GifFrame {
	    index: number;
	    texture: vf.Texture;
	    delayTime: number;
	    constructor(index: number, texture: vf.Texture, delayTime: number);
	}

}
declare module 'src/utils/GifSequence' {
	import { GifSprite } from 'src/display/private/GifSprite';
	import { GifFrame } from 'src/utils/GifFrames';
	export class GifSequence {
	    sprite: GifSprite;
	    name: string;
	    frames: Array<GifFrame>;
	    loopCount: number;
	    private _playing;
	    private _nextFrameTime;
	    private _loopedCount;
	    private _speedScale;
	    private _timeDistance;
	    constructor(sprite: GifSprite, name: string, frames: Array<GifFrame>, loopCount: number);
	    setEndlessLoop(): void;
	    get speedScale(): number;
	    set speedScale(value: number);
	    get duration(): number;
	    get playing(): boolean;
	    stop(skipEmit?: boolean): void;
	    play(): boolean;
	    private get currentFrameIndex();
	    get loopedCount(): number;
	    private update;
	}

}
declare module 'src/display/private/GifSprite' {
	///   types="@vf.js/vf" />
	import { GifFrame, GifFrames } from 'src/utils/GifFrames';
	import { GifSequence } from 'src/utils/GifSequence';
	export class GifSprite extends vf.Sprite {
	    static EVENT: {
	        FRAME_CHANGED: string;
	        PLAY: string;
	        STOP: string;
	        COMPLETE: string;
	        END: string;
	    };
	    private _frames;
	    private _sequences;
	    private _currentSequence;
	    private _currentFrame;
	    constructor(resource: vf.LoaderResource | string | GifFrames);
	    get gifFrames(): GifFrames;
	    get totalFrames(): number;
	    getSequence(name?: string): GifSequence;
	    addSequence(name: string, frames: Array<number>, loopCount?: number): GifSequence;
	    private _addSequence;
	    setSequence(name: string, play?: boolean): void;
	    destroy(): void;
	    play(): void;
	    stop(): void;
	    setFrame(frame: number): void;
	    setGifFrame(frame: GifFrame): void;
	    gotoAndStop(frame: number): void;
	    gotoAndPlay(frame: number): void;
	    get currentFrame(): number;
	    get currentGifFrame(): GifFrame;
	    get currentSequence(): GifSequence;
	    get playing(): boolean;
	    get speedScale(): number;
	    set speedScale(value: number);
	}

}
declare module 'src/display/Image' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { MaskSprite } from 'src/core/MaskSprite';
	import { GifSprite } from 'src/display/private/GifSprite';
	/**
	 * 图片
	 *
	 * @example let image = new vf.gui.Image();
	 *
	 */
	export class Image extends DisplayObject implements MaskSprite {
	    constructor();
	    /** 可以支持遮罩的组件 */
	    maskSprite(): vf.Sprite;
	    protected _sprite: vf.Sprite | vf.TilingSprite | vf.NineSlicePlane | GifSprite | undefined;
	    protected _texture: vf.Texture | undefined;
	    protected _source: number | string | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | undefined;
	    /**
	     * 图像路径或位图对象
	     */
	    private _src;
	    private _oldSrc?;
	    get src(): number | string | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | undefined;
	    set src(value: number | string | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | undefined);
	    private _isGif;
	    private _scale9Grid?;
	    private _oldScale9Grid?;
	    /**
	     * 矩形区域，它定义素材对象的九个缩放区域。
	     *
	     * fillMode = scale 时，[leftWidth,rightWidth,topHeight,bottomHeight]
	     *
	     * fillMode = repeat 是，[scalex,scaley,x,y]
	     */
	    get scale9Grid(): any[] | number[] | undefined;
	    set scale9Grid(value: any[] | number[] | undefined);
	    private _fillMode?;
	    private _oldFillMode?;
	    /**
	     * 填充模式
	     * 设置scale后，可设置scale9Grid进行调整缩放区域
	     */
	    get fillMode(): "repeat" | "no-repeat" | "scale" | undefined;
	    set fillMode(value: "repeat" | "no-repeat" | "scale" | undefined);
	    /**
	     * 锚点，调整位图的坐标中点 0-1
	     */
	    get anchorX(): number;
	    set anchorX(value: number);
	    /**
	     * 锚点，调整位图的坐标中点 0-1
	     */
	    get anchorY(): number;
	    set anchorY(value: number);
	    setSpeiteSize(unscaledWidth?: number, unscaledHeight?: number): void;
	    protected measure(): void;
	    protected srcSystem(): void;
	    protected commitProperties(): void;
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    release(): void;
	}

}
declare module 'src/display/private/InputBase' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { ClickEvent, InteractionEvent } from 'src/interaction/Index';
	/**
	 * 输入对象的基础类
	 */
	export class InputBase extends DisplayObject {
	    constructor();
	    /** 是否开启鼠标或触摸点击，开启后，接收TouchMouseEvent */
	    get interactabled(): boolean;
	    set interactabled(value: boolean);
	    protected clickEvent: ClickEvent;
	    private _currentState;
	    protected get currentState(): "up" | "move" | "down" | "disabled";
	    protected set currentState(value: "up" | "move" | "down" | "disabled");
	    protected _tabIndex: undefined | number;
	    protected _tabGroup: undefined | string;
	    protected _focused: boolean;
	    protected _useTab: boolean;
	    protected _usePrev: boolean;
	    protected _useNext: boolean;
	    protected _down: boolean;
	    private _clickSound?;
	    get clickSound(): string | undefined;
	    set clickSound(value: string | undefined);
	    set double(value: boolean);
	    get double(): boolean;
	    private _useMoveEvent;
	    set useMoveEvent(value: boolean);
	    get useMoveEvent(): boolean;
	    /**
	     * 状态皮肤，
	     */
	    up?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    /**
	     * 状态皮肤，
	     */
	    down?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    /**
	     * 状态皮肤，
	     */
	    move?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    /**
	     * 状态皮肤，
	     */
	    disabled?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    /**
	     * 选中状态皮肤，
	     */
	    upAndSelected?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    /**
	     * 选中状态皮肤，
	     */
	    downAndSelected?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    /**
	     * 选中状态皮肤，
	     */
	    moveAndSelected?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    /**
	     * 选中状态皮肤，
	     */
	    disabledAndSelected?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    protected onMove(): void;
	    protected onHover(): void;
	    protected onPress(e: InteractionEvent, thisObj: DisplayObject, isPress: boolean): void;
	    protected onClick(e: InteractionEvent): void;
	    protected keyDownEvent(event: WheelEvent | Event): void;
	    protected documentMouseDown(): void;
	    private keyDownEventBind;
	    protected _bindEvents(): void;
	    protected _clearEvents(): void;
	    focus(): void;
	    blur(): void;
	    release(): void;
	    setTabIndex(index: number | undefined, group: string | undefined): void;
	}

}
declare module 'src/display/Button' {
	import { Label } from 'src/display/Label';
	import { Image } from 'src/display/Image';
	import { InputBase } from 'src/display/private/InputBase';
	/**
	 * 按钮
	 *
	 * @example let button = new vf.gui.Button();
	 *
	 *
	 */
	export class Button extends InputBase {
	    constructor();
	    protected _selectedStr: "AndSelected" | "";
	    protected _oldState: string;
	    private _offsetY;
	    /** 状态展示 */
	    readonly img: Image;
	    /** 文字展示 */
	    readonly label: Label;
	    private _text;
	    /**
	     * 设置按钮的文本内容
	     */
	    get text(): string;
	    set text(value: string);
	    /**
	     *  文本偏移
	     */
	    get textOffsetY(): number;
	    set textOffsetY(value: number);
	    setSelected(value: boolean): void;
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    release(): void;
	    protected onStateChange(label: Button, state: string): void;
	}

}
declare module 'src/display/CheckBox' {
	import { Label } from 'src/display/Label';
	import { Button } from 'src/display/Button';
	/**
	 * 单选\复选框
	 *
	 * 设置checkGroup后，进行分组。 分组后，可理解为复选框。
	 *
	 * @example let checkBox = new vf.gui.CheckBox();
	 *
	 *
	 */
	export class CheckBox extends Button {
	    constructor();
	    /**
	     * 设置值
	     */
	    private _value;
	    /**
	     * 设置是否选中
	     * */
	    private _checked;
	    /**
	     * 获取或设置当前选中的值
	     */
	    get selectedValue(): string | undefined;
	    /**
	     * 设置分组名
	     */
	    get checkGroup(): string | undefined;
	    set checkGroup(value: string | undefined);
	    /**
	     * 获取设置默认值
	     */
	    get value(): string;
	    set value(value: string);
	    /**
	     * 设置是否选中
	     * @default false
	     */
	    get checked(): boolean;
	    set checked(value: boolean);
	    protected onClick(e: any): void;
	    protected onLabelChange(label: Label): void;
	    release(): void;
	}

}
declare module 'src/interaction/InputController' {
	import { DisplayObject } from 'src/core/DisplayObject';
	import { CheckBox } from 'src/display/CheckBox';
	interface CheckGroupObject {
	    groups: {
	        [key: string]: {
	            [value: string]: CheckBox;
	        };
	    };
	    values: {
	        [key: string]: string | undefined;
	    };
	}
	/**
	 *
	 * @private
	 */
	export const tabGroups: {
	    [key: string]: DisplayObject[];
	};
	/**
	 *
	 * @private
	 */
	export const _checkGroupObject: CheckGroupObject;
	/**
	 * 注册组件
	 * @param item
	 * @param tabIndex 切换位置
	 * @param tabGroup 分组名
	 * @returns 依据tabIndex返回是否需要排序 0，-1，1
	 */
	export function registrer(item: DisplayObject, tabIndex: number, tabGroup?: string): void;
	/** 失去焦点时 */
	export function blur(): void;
	/** 设置当前输入组件 */
	export function set(item: DisplayObject): void;
	/** 清楚当前设置的组件 */
	export function clear(): void;
	/** 一般再按下键盘tab健执行 焦点获取与设置 */
	export function fireTab(): void;
	/** 一般再按下键盘向下箭头执行 焦点获取与设置 */
	export function fireNext(): void;
	/** 一般再按下键盘向上箭头执行 焦点获取与设置 */
	export function firePrev(): void;
	/**
	 * 注册分组，一般用于checkBox组件的分组操作
	 *
	 *  ==== 目前没有实现卸载，如果无限制创建checkbox并设置分组可能引发泄露 ====
	 *
	 * checkGroups = [key]:{["value"]:cb}
	 */
	export function registrerCheckGroup(cb: CheckBox): void;
	/**
	 * 注销指定分组或指定分组的子项
	 * @param cb CheckBox
	 */
	export function unRegistrerCheckGroup(cb: CheckBox): void;
	/** 更新分组中选中的checkbox组件  */
	export function updateCheckGroupSelected(cb: CheckBox): void;
	/** 获取分组中选中的checkbox值 */
	export function getCheckGroupSelectedValue(name: string): string | undefined;
	/** 设置选中 */
	export function setCheckGroupSelectedValue(name: string, uuid: string): void;
	export {};

}
declare module 'src/display/Container' {
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 * 基础容器
	 *
	 * 设置checkGroup后，进行分组。 分组后，可理解为复选框。
	 *
	 * @example let container = new vf.gui.Container();
	 *
	 */
	export class Container extends DisplayObject {
	    constructor();
	    /**
	     * 确定指定显示对象是 DisplayObjectContainer 实例的子项或该实例本身。搜索包括整个显示列表（其中包括此 DisplayObjectContainer 实例）。
	     * 孙项、曾孙项等，每项都返回 true。
	     * @param child 要测试的子对象。
	     * @returns 如果 child 对象是 DisplayObjectContainer 的子项或容器本身，则为 true；否则为 false。
	     */
	    contains(child: DisplayObject): boolean;
	}

}
declare module 'src/display/private/GraphicsCore' {
	///   types="@vf.js/vf" />
	/**
	 * 图形逻辑基类
	 */
	export class GraphicsCore extends vf.Graphics {
	    private _lineType;
	    constructor(geometry?: vf.GraphicsGeometry | undefined);
	    private RatioLine;
	    private RatioNone;
	    lineStyle(width?: number, color?: number, alpha?: number, alignment?: number, native?: boolean, lineType?: "full" | "dash"): vf.Graphics;
	    lineTo(x: number, y: number): vf.Graphics;
	    arc(cx: number, cy: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): vf.Graphics;
	    /**
	     * 画椭圆
	    */
	    drawEllipse(xx: number, yy: number, width: number, height: number): vf.Graphics;
	    /**
	     * 圆角矩形
	     */
	    drawRoundedRect(x: number, y: number, width: number, height: number, radius: number): vf.Graphics;
	    /**
	     * 闭合路线
	     */
	    drawPolygonOne(path: vf.Point[], closeStroke?: boolean): vf.Graphics;
	    /**
	     * 判断一个点是否在贝塞尔曲线上
	     * B_{3}(t) = (1 - t)^3P_0 + 3t(1 - t)^2P_1 + 3t^2(1 - t)P_2 + t^3P_3 , t  in[0, 1]
	     *
	     * (x3-3*x2+3*x1-x0)t^3 + (3*x2-6*x1+3*x0)t^2 + (3*x1-3*x0)t + x0
	     *
	     * cpX cpY 控制点一
	     * cpX2 cpY2 控制点二
	     * toX toY 曲线目标点
	     * fromX fromY 曲线起始点
	     * x y 当前点
	     */
	    checOnkBezier(cpX: number, cpY: number, cpX2: number, cpY2: number, toX: number, toY: number, fromX: number, fromY: number, x: number, y: number): number;
	    /**
	     *
	     */
	    quadraticCurveTo(cpX: number, cpY: number, toX: number, toY: number): vf.Graphics;
	    /**
	     * 贝塞尔曲线
	     */
	    bezierCurveTo(cpX: number, cpY: number, cpX2: number, cpY2: number, toX: number, toY: number): vf.Graphics;
	    private drawBezierDash;
	    /**
	    * 获取二阶贝塞尔曲线点信息(近似值 ， n越大值越准确)
	    */
	    quadPointLength(fromX: number, fromY: number, cpX: number, cpY: number, toX: number, toY: number, n?: number): vf.Point[];
	    /**
	     * 获取三阶贝塞尔曲线点信息(近似值 ， n越大值越准确)
	     */
	    bezierPointLength(fromX: number, fromY: number, cpX: number, cpY: number, cpX2: number, cpY2: number, toX: number, toY: number, n?: number): vf.Point[];
	    /**
	     * 根据点取长度
	     */
	    private bezierLength;
	    private bezierToLineData;
	    private pointDistance;
	    /**
	     * 获取线段起始位置或者终止位置角度
	     */
	    getLineRotation(lineTyle: "M" | "L" | "Q" | "C", isBeignPoint: boolean, fromX: number, fromY: number, toX: number, toY: number, cpX?: number, cpY?: number, cpX2?: number, cpY2?: number): number;
	}

}
declare module 'src/display/private/GraphBase' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { MaskSprite } from 'src/core/MaskSprite';
	import { GraphicsCore } from 'src/display/private/GraphicsCore';
	/**
	 * 绘制图形基类
	 */
	export class GraphBase extends DisplayObject implements MaskSprite {
	    constructor();
	    readonly graphics: GraphicsCore;
	    canvas?: HTMLCanvasElement;
	    context?: CanvasRenderingContext2D;
	    texture?: vf.Texture;
	    /** 可以支持遮罩的组件 */
	    maskSprite(): GraphicsCore;
	    /**
	     * 半径
	     */
	    protected _radius: number;
	    get radius(): number;
	    set radius(value: number);
	    /**
	     *
	     */
	    protected _alignment: number;
	    get alignment(): number;
	    set alignment(value: number);
	    /**
	     * 线条样式
	     */
	    protected _lineType: "full" | "dash";
	    get lineType(): "full" | "dash";
	    set lineType(value: "full" | "dash");
	    /**
	     * 线条颜色
	     */
	    protected _lineColor: any;
	    get lineColor(): any;
	    set lineColor(value: any);
	    /**
	     * 线条粗细
	     */
	    protected _lineWidth: number;
	    get lineWidth(): number;
	    set lineWidth(value: number);
	    /**
	     * 线条透明度
	     */
	    protected _lineAlpha: number;
	    get lineAlpha(): number;
	    set lineAlpha(value: number);
	    /**
	     * 填充透明度
	     */
	    protected _fillAlpha: number;
	    get fillAlpha(): number;
	    set fillAlpha(value: number);
	    /**
	     * 颜色
	     */
	    get fillColor(): number[];
	    set fillColor(value: number[]);
	    /**
	     * 颜色
	     */
	    protected _color?: any;
	    get color(): any;
	    set color(value: any);
	    /**
	     * 锚点，调整位图的坐标中点 0-1
	     */
	    get anchorX(): number;
	    set anchorX(value: number);
	    /**
	     * 锚点，调整位图的坐标中点 0-1
	     */
	    get anchorY(): number;
	    set anchorY(value: number);
	    /**
	     * 子类重写
	     */
	    drawGraph(): void;
	    release(): void;
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	}

}
declare module 'src/display/Circle' {
	import { GraphBase } from 'src/display/private/GraphBase';
	/**
	 * 绘制圆形
	 *
	 * 不设置 lineWidth 或 color 圆形不可见
	 *
	 * @example let circle = new vf.gui.Circle();
	 *
	 *
	 */
	export class Circle extends GraphBase {
	    constructor();
	    /**
	     * 开始绘制角度
	     */
	    protected _startAngle: number;
	    get startAngle(): number;
	    set startAngle(value: number);
	    /**
	     * 结束角度
	     */
	    protected _endAngle: number;
	    get endAngle(): number;
	    set endAngle(value: number);
	    /**
	     * 逆时针绘制
	     */
	    protected _anticlockwise: boolean;
	    get anticlockwise(): boolean;
	    set anticlockwise(value: boolean);
	    drawGraph(): void;
	}

}
declare module 'src/display/Star' {
	import { GraphBase } from 'src/display/private/GraphBase';
	export class Star extends GraphBase {
	    constructor();
	    private path;
	    private PI_2;
	    private _triangleNum;
	    private RADIUS_V;
	    private _innerRadius;
	    drawGraph(): void;
	    get triangleNum(): number;
	    set triangleNum(value: number);
	    get innerRadius(): number;
	    set innerRadius(value: number);
	    private setStarPath;
	}

}
declare module 'src/display/Rect' {
	import { GraphBase } from 'src/display/private/GraphBase';
	/**
	 * 绘制矩形或圆角矩形
	 *
	 * 不设置 lineWidth 或 color 矩形不可见
	 *
	 * @example let rect = new vf.gui.Rect();
	 *
	 */
	export class Rect extends GraphBase {
	    constructor();
	    drawGraph(): void;
	}

}
declare module 'src/display/VideoBtn' {
	import { Container } from 'src/display/Container';
	export class VideoBtn extends Container {
	    private _states;
	    private _bgCircle?;
	    private _thumbTriangle?;
	    private _rect1?;
	    private _rect2?;
	    constructor();
	    setStates(states: "play" | "pause"): void;
	    updateDisplayList(): void;
	    private refreshPlay;
	    private refreshPause;
	    private initBgCircle;
	    private onHover;
	    private initTrangle;
	    private initLine;
	    release(): void;
	}

}
declare module 'src/display/Video' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 * 播放器组件
	 *
	 */
	export class Video extends DisplayObject {
	    private _video;
	    private _videoHasEvent;
	    private _src;
	    protected _canvasBounds: {
	        top: number;
	        left: number;
	        width: number;
	        height: number;
	    } | undefined;
	    protected _lastRenderer: vf.Renderer | undefined;
	    protected _resolution: number;
	    private _canplayFun;
	    private _canplaythroughFun;
	    private _completeFun;
	    private _endedFun;
	    private _loadeddataFun;
	    private _durationchangeFun;
	    private _pauseFun;
	    private _playFun;
	    private _autoplay;
	    private _canPlayFirst;
	    private _videoTextrue;
	    private _sprite;
	    private _poster;
	    private _posterImg?;
	    private _videoBtn?;
	    private _firstLoad;
	    private _muted;
	    private _loop;
	    private _controls;
	    private _volume;
	    private _currentTime;
	    private _oldPoster;
	    private _oldSrc;
	    private _canPlay;
	    private _visibleStatus;
	    private _elemDraw;
	    private _isplaying;
	    forceElementDraw: boolean;
	    constructor();
	    private createVideoBtn;
	    private clickAudio;
	    /**
	     *  目前 设置src才会添加sprite到舞台
	     *  创建sprite需要根据src获取纹理
	     */
	    private createVideoSource;
	    private canplayFun;
	    private canplaythroughFun;
	    private completeFun;
	    private pauseFun;
	    private playFun;
	    private endedFun;
	    private loadeddataFun;
	    private checkComatibility;
	    private durationchangeFun;
	    private checkVideoPlay;
	    get x(): number;
	    set x(value: number);
	    get y(): number;
	    set y(value: number);
	    private setPos;
	    private _getCanvasBounds;
	    private updateSystem;
	    private updatePostion;
	    private _lastPostion;
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    private updataPoster;
	    private clearPoster;
	    /**
	     * 支持的参数们~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	     */
	    private _silent;
	    set silent(value: any);
	    get silent(): any;
	    private _audio;
	    set audio(value: any);
	    get audio(): any;
	    get src(): any;
	    set src(value: any);
	    get srcObject(): any;
	    set srcObject(value: any);
	    get autoplay(): boolean;
	    set autoplay(value: boolean);
	    get loop(): boolean;
	    set loop(value: boolean);
	    get poster(): string;
	    set poster(value: string);
	    get muted(): boolean;
	    set muted(boo: boolean);
	    get controls(): boolean;
	    set controls(boo: boolean);
	    get volume(): number;
	    set volume(value: number);
	    get visible(): boolean;
	    set visible(boo: boolean);
	    get videoElement(): HTMLVideoElement;
	    get currentTime(): number;
	    set currentTime(value: number);
	    /**
	     * 设置分组名
	     */
	    get videoGroup(): string | undefined;
	    set videoGroup(value: string | undefined);
	    /**
	     * 只读的属性们~~~~~~~~~~~~~~~~
	     * */
	    get duration(): number;
	    get isPlaying(): boolean;
	    /**
	    * 支持的方法们~~~··~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	    **/
	    play(): void;
	    pause(): void;
	    private _oldX;
	    private _oldY;
	    private _fullStates;
	    requestFullScreen(): void;
	    private fullScreen;
	    private requestFullScreenDom;
	    exitFullscreen(): void;
	    exitFullscreenDom(): void;
	    private clearSource;
	    private clearVideoBtn;
	    private clearVideoEvent;
	    private clearVideo;
	    private clearSprite;
	    private useNativeAudio;
	    private nativeEmit;
	    release(): void;
	}

}
declare module 'src/interaction/VideoGroupController' {
	import { Video } from 'src/display/Video';
	interface VideoGroupObject {
	    groups: {
	        [key: string]: {
	            [value: string]: Video;
	        };
	    };
	    values: {
	        [key: string]: string | undefined;
	    };
	}
	export const _videoGroupObject: VideoGroupObject;
	export function registrerVideoGroup(cb: Video): void;
	/**
	 * 注销指定分组或指定分组的子项
	 * @param cb video
	 */
	export function unRegistrerVideoGroup(cb: Video): void;
	/** 更新分组中选中的checkbox组件  */
	export function updateVideoGroupStates(cb: Video): void;
	export {};

}
declare module 'src/interaction/MouseScrollEvent' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 * 鼠标滑轮事件
	 *
	 *  可侦听事件(未实现):
	 * ```
	 *  {InteractionEvent}.MouseScroll.xxxxxx.
	 * ```
	 *  可赋值方法:
	 * ```
	 * oonMouseScroll: ((e: WheelEvent,delta: vf.Point) => void) | undefined
	 * ```
	 *
	 * @example 可查看 `Slider` 源码
	 *
	 * @since 1.0.0
	 */
	export class MouseScrollEvent {
	    /**
	     *
	     * @param obj 需要绑定的对象
	     * @param preventDefault 是否组织系统默认的事件触发
	     */
	    constructor(obj: DisplayObject, preventDefault: boolean);
	    id: number;
	    private obj;
	    private preventDefault;
	    private delta;
	    private mouseScrllBind;
	    private isStop;
	    startEvent(): void;
	    private _onMouseScroll;
	    private _onHover;
	    private _onMouseOut;
	    stopEvent(): void;
	    remove(): void;
	    onMouseScroll: ((e: WheelEvent, delta: vf.Point) => void) | undefined;
	}

}
declare module 'src/event/ComponentEvent' {
	/**
	 * 特定属性改变时,通常为了去系统事件区分，UI组件的事件名为大写
	 * 1. CheckBox 的 checked 改变时
	 * 2. Label 的 text 改变时
	 * 3. SpriteAnimated 的 animationName 改变时
	 * 4. Button 文字改变
	 * 5. ScrollingContainer 拖动改变时
	 * 6. Slider 滑动改变后
	 * 7. SpriteAnimated 动画改变后
	 * 8. ConnectLine 连线完成时
	 */
	export const CHANGE = "CHANGE";
	/**
	 * 状态改变中
	 *
	 * slider 滑动时
	 */
	export const CHANGEING = "CHANGEING";
	/**
	 * 状态切换完成时
	 *
	 * 1. SpriteAnimated 每次播放完时，触发(loop = false时)
	 * 2. Image 图片加载完成时
	 * 3. Slider 滑动完成
	 * 4. Timeline  每次播放完时，触发(loop = false时)
	 * 5. FollowLine 完成一次划线
	 */
	export const COMPLETE = "COMPLETE";
	/**
	 * 状态发生改变时
	 */
	export const STATE_CHANGE = "STATE_CHANGE";
	/**
	 * 状态切换完成时
	 *
	 * SpriteAnimated 每次播放完时，，触发(loop = true时)
	 */
	export const LOOP = "LOOP";
	/**
	 * 组件被添加前
	 */
	export const ADD = "add";
	/**
	 * 组件被添加时
	 */
	export const ADDED = "added";
	/**
	 * 组件被移除时
	 */
	export const REMOVEED = "removed";
	/**
	 * 组件大小改变后
	 */
	export const RESIZE = "RESIZE";
	/**
	 * 组件位置移动
	 */
	export const MOVE = "MOVE";
	/**
	 * 组件创建完成后
	 */
	export const CREATION_COMPLETE = "CREATION_COMPLETE";
	/**
	 * 拖拽组件按下
	 */
	export const DRAG_DOWN = "DRAG_DOWN";
	/**
	 * 拖拽组件按下
	 */
	export const DRAG_UP = "DRAG_UP";
	/**
	 * 拖拽组件hover
	 */
	export const DRAG_HOVER = "DRAG_HOVER";
	/**
	 * 拖拽组件mouseover
	 */
	export const DRAG_MOUSEENTER = "DRAG_MOUSEENTER";
	/**
	 * 拖拽组件mouseleave
	 */
	export const DRAG_MOUSELEAVE = "DRAG_MOUSELEAVE";
	/**
	 * 组件拖动开始之前
	 */
	export const DRAG_START_BEFORE = "DRAG_START_BEFORE";
	/**
	 * 组件拖动开始时
	 */
	export const DRAG_START = "DRAG_START";
	/**
	 * 组件拖动结束之前
	 */
	export const DRAG_END_BEFORE = "DRAG_END_BEFORE";
	/**
	 * 组件拖动结束时 （如果绑定接收容器并拖动到接收容器中，不会触发此事件）
	 */
	export const DRAG_END = "DRAG_END";
	/**
	 * 组件拖动中
	 */
	export const DRAG_MOVE = "DRAG_MOVE";
	/**
	 * 组件拖动到接收目标中之前
	 */
	export const DRAG_TARGET_BEFORE = "DRAG_TARGET_BEFORE";
	/**
	 * 组件拖动到接收目标中
	 */
	export const DRAG_TARGET = "DRAG_TARGET";
	/**
	 * 有拖拽物掉落到此容器时触发
	 */
	export const DROP_TARGET = "DROP_TARGET";
	/**
	 * 播放音效 {name,mode}
	 */
	export const PLAY_AUDIO = "PLAY_AUDIO";
	/**
	 * 组件宽度发生变化(目前文本换行需要用到)
	 */
	export const WIDTH_CHANGE = "WIDTH_CHANGE";

}
declare module 'src/interaction/GroupController' {
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 *
	 * @private
	 */
	export const _GroupObject: Map<string, {
	    [key: string]: DisplayObject;
	}>;
	/**
	 * 具有ID属性的组件都会添加到本组
	 * @private
	 */
	export const _idObject: Map<string, DisplayObject>;
	export function getObjectById(id: string): DisplayObject | undefined;
	export function registrerID(ui: DisplayObject): boolean;
	export function unRegistrerID(ui: DisplayObject): void;
	/**
	 * 注册分组，
	 */
	export function registrerGroup(ui: DisplayObject): void;
	/**
	 * 注销指定分组或指定分组的子项
	 */
	export function unRegistrerGroup(ui: DisplayObject): void;
	/** 设置选中 */
	export function getGroup(name?: string): {
	    [key: string]: DisplayObject;
	} | undefined;

}
declare module 'src/interaction/Index' {
	import { ClickEvent } from 'src/interaction/ClickEvent';
	import * as DragDropController from 'src/interaction/DragDropController';
	import { DragEvent } from 'src/interaction/DragEvent';
	import * as InputController from 'src/interaction/InputController';
	import * as VideoGroupController from 'src/interaction/VideoGroupController';
	import { MouseScrollEvent } from 'src/interaction/MouseScrollEvent';
	import { InteractionEvent } from 'src/event/InteractionEvent';
	import { TouchMouseEvent } from 'src/event/TouchMouseEvent';
	import * as ComponentEvent from 'src/event/ComponentEvent';
	import * as GroupController from 'src/interaction/GroupController';
	export { ClickEvent, DragDropController, DragEvent, InputController, MouseScrollEvent, InteractionEvent, TouchMouseEvent, ComponentEvent, GroupController, VideoGroupController };

}
declare module 'src/layout/CSSSSystem' {
	/** ===================== mask  ===================== */
	/** ===================== font  ===================== */
	export function updateFontStyle(target: any, key: string, value: any): void;
	export function color(target: any, key: string, value: any): void;
	export function ColorRGBA(target: any, key: "fillColor" | "lineColor", value: number[] | number[][]): void;
	export function lineWidth(target: any, key: "lineWidth", value: number): void;

}
declare module 'src/enum/TracingEnum' {
	export const enum Operate {
	    Add = 0,
	    Clear = 1,
	    Remove = 2
	}
	export const enum Mode {
	    Check = 0,
	    Teach = 1,
	    Auto = 2,
	    Strict = 3,
	    Fill = 4
	}
	export const enum Result {
	    Uncomplete = 0,
	    Correct = 1,
	    Incorrect = 2,
	    Complete = 3
	}

}
declare module 'src/enum/FontWeight' {
	/** 字体粗细 */
	export const enum FontWeight {
	    'normal' = "normal",
	    'bold' = "bold",
	    'bolder' = "bolder",
	    'lighter' = "lighter",
	    'n100' = 100,
	    'n200' = 200,
	    'n300' = 300,
	    'n400' = 400,
	    'n500' = 500,
	    'n600' = 600,
	    'n700' = 700,
	    'n800' = 800,
	    'n900' = 900
	}

}
declare module 'src/enum/Index' {
	import * as FollowLineEnum from 'src/enum/FollowLineEnum';
	import * as TracingEnum from 'src/enum/TracingEnum';
	export { FontWeight } from 'src/enum/FontWeight';
	export { FollowLineEnum, TracingEnum };

}
declare module 'src/layout/CSSStyle' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { FontWeight } from 'src/enum/Index';
	/**
	 * 	定位方式
	 *
	 *  元素的位置通过 "left", "top", "right" 以及 "bottom" 属性进行规定。
	 *
	 * 	absolute 生成绝对定位的元素，相对于第一个父元素进行定位。
	 *
	 *  fixed 生成绝对定位的元素，相对于舞台进行定位。
	 *
	 *  static 没有定位，元素出现在正常的流中（忽略 top, bottom, left, right 或者 z-index 声明）。
	 */
	export type Position = "absolute" | "fixed" | "static";
	/** 对齐方式 父级如果是grid布局，会忽略当前居中模式 */
	export type Align = "flex-start" | "flex-end" | "center";
	/** 布局模式 */
	export type Display = "none" | "block" | "grid";
	/**
	 * 组件样式表
	 */
	export class CSSStyle {
	    constructor(target: DisplayObject);
	    parent: DisplayObject;
	    release(): void;
	    /**
	     * 规定元素的显示类型。布局模式
	     *
	     * grid 模式下，子节点会忽略left,top,right，bottom,width,height等
	     *
	     * none 模式下，忽略style
	     * */
	    private _display;
	    get display(): Display;
	    set display(value: Display);
	    /**
	     * 规定元素的定位类型。
	     * */
	    private _position;
	    get position(): Position;
	    set position(value: Position);
	    /**
	     * 在容器里面的水平位置（左中右）
	     */
	    private _justifyContent?;
	    get justifyContent(): "center" | "flex-start" | "flex-end" | undefined;
	    set justifyContent(value: "center" | "flex-start" | "flex-end" | undefined);
	    /**
	     * 在容器里面的垂直位置（上中下）
	     */
	    private _alignContent?;
	    get alignContent(): "center" | "flex-start" | "flex-end" | undefined;
	    set alignContent(value: "center" | "flex-start" | "flex-end" | undefined);
	    /**
	     * 基于 网格列的维度，去定义网格线的名称和网格轨道的尺寸大小。
	     *
	     * 方式一 [80,90,100]|["30%","40%","30%"] 第一列宽度80，第二列宽度，第三列宽度100
	     *
	     * 方式二 ["repeat",3,100] 三列，宽度都为100像素
	     */
	    private _gridTemplateColumns?;
	    get gridTemplateColumns(): number[] | string[] | [string, number, number] | undefined;
	    set gridTemplateColumns(value: number[] | string[] | [string, number, number] | undefined);
	    /**
	     * 设置列间距
	     */
	    private _gridColumnGap?;
	    get gridColumnGap(): number | undefined;
	    set gridColumnGap(value: number | undefined);
	    /**
	     * 基于 网格行的维度，去定义网格线的名称和网格轨道的尺寸大小。
	     *
	     * 方式一 [80,90,100]|["30%","40%","30%"] 第一行高度80，第二行高度90，第三行行高度100
	     *
	     * 方式二 ["repeat",3,100] 三行，宽度都为100像素
	     */
	    private _gridTemplateRows?;
	    get gridTemplateRows(): number[] | string[] | [string, number, number] | undefined;
	    set gridTemplateRows(value: number[] | string[] | [string, number, number] | undefined);
	    /**
	     * 设置行间距
	     */
	    private _gridRowGap?;
	    get gridRowGap(): number | undefined;
	    set gridRowGap(value: number | undefined);
	    /**
	     * 表示显示对象的宽度，以像素为单位。
	     * */
	    get width(): number | string;
	    set width(value: number | string);
	    /**
	     * 表示显示对象的高度，以像素为单位。
	     * */
	    get height(): number | string;
	    set height(value: number | string);
	    /**
	     * 设置元素的最小宽度。
	     */
	    get minWidth(): number;
	    set minWidth(value: number);
	    /**
	     * 设置元素的最大宽度。
	     */
	    get maxWidth(): number;
	    set maxWidth(value: number);
	    /**
	     * 设置元素的最小高度。
	     */
	    get maxHeight(): number;
	    set maxHeight(value: number);
	    /**
	     * 设置元素的最大高度。
	     * */
	    get minHeight(): number;
	    set minHeight(value: number);
	    /**
	     * 设置定位元素左外边距边界与其容器左边界之间的偏移。
	     * */
	    get left(): any;
	    set left(value: any);
	    /**
	     * 设置定位元素的上外边距边界与其容器上边界之间的偏移。
	     * */
	    get top(): any;
	    set top(value: any);
	    /**
	     * 设置定位元素右外边距边界与其容器右边界之间的偏移。
	     * */
	    get right(): any;
	    set right(value: any);
	    /**
	     * 设置定位元素下外边距边界与其容器下边界之间的偏移。
	     * */
	    get bottom(): any;
	    set bottom(value: any);
	    /**
	     * 缩放
	     * */
	    get scaleX(): number;
	    set scaleX(value: number);
	    /**
	     * 缩放
	     * */
	    get scaleY(): number;
	    set scaleY(value: number);
	    /**
	     * 设置元素水平拉伸扭曲（角度）。
	     * */
	    get skewX(): number;
	    set skewX(value: number);
	    /**
	     * 设置元素垂直拉伸扭曲（角度）。
	     * */
	    get skewY(): number;
	    set skewY(value: number);
	    /**
	     * 设置元素旋转 （角度）
	    */
	    get rotate(): number;
	    set rotate(value: number);
	    /**
	     * 设置元素旋转 （角度）
	    */
	    get rotation(): number;
	    set rotation(value: number);
	    /**
	     * 轴点 像素值
	     */
	    get pivotX(): number;
	    set pivotX(value: number);
	    /**
	     * 轴点 像素值
	     */
	    get pivotY(): number;
	    set pivotY(value: number);
	    /**
	      * 调整元素的色调，取消设置0xFFFFFF
	      */
	    get tint(): number;
	    set tint(value: number);
	    /**
	     * 表示指定对象的 Alpha 透明度值。有效值为0（完全透明）～ 1（完全不透明）。
	     * */
	    get alpha(): number;
	    set alpha(value: number);
	    /**
	     * 显示对象是否可见
	     * */
	    get visible(): boolean;
	    set visible(value: boolean);
	    get visibility(): "visible" | "hidden";
	    set visibility(value: "visible" | "hidden");
	    /**
	     * 设置元件的背景颜色。（16进制数字0xffffff
	     * */
	    get backgroundColor(): number | number[] | number[][] | undefined;
	    set backgroundColor(value: number | number[] | number[][] | undefined);
	    /**
	     * 设置元素的背景圆角
	     */
	    get backgroundRadius(): number;
	    set backgroundRadius(value: number);
	    /**
	     * 设置元素的背景图像。backgroundImage = "./xxx.png"
	     * */
	    get backgroundImage(): string | undefined;
	    set backgroundImage(value: string | undefined);
	    /**
	     * 设置 backgroundImage 后 ，设置背景图像的X位置
	     * */
	    get backgroundPositionX(): number;
	    set backgroundPositionX(value: number);
	    /**
	     * 设置 backgroundImage 后 ，设置背景图像的Y位置
	     * */
	    get backgroundPositionY(): number;
	    set backgroundPositionY(value: number);
	    /**
	     * 设置 backgroundImage 后， 规定背景图像的尺寸。 [width,height]
	     * */
	    get backgroundSize(): number[] | undefined;
	    set backgroundSize(value: number[] | undefined);
	    /**
	     * 设置 backgroundImage 后，设置是否及如何重复背景图像。
	     * repeat重复
	     * no-repeat不重复，
	     */
	    get backgroundRepeat(): "repeat" | "no-repeat";
	    set backgroundRepeat(value: "repeat" | "no-repeat");
	    /**
	     * 设置背景透明度
	     */
	    get backgroundAlpha(): number;
	    set backgroundAlpha(value: number);
	    /**
	     * 遮罩图
	     */
	    get maskImage(): string | vf.Graphics | import("../core/MaskSprite").MaskSprite | undefined;
	    set maskImage(value: string | vf.Graphics | import("../core/MaskSprite").MaskSprite | undefined);
	    /**
	     * 设置位数 [x,y]
	     */
	    get maskPosition(): number[] | undefined;
	    set maskPosition(value: number[] | undefined);
	    /**
	     * 设置遮罩位图的大小
	     */
	    get maskSize(): number[] | undefined;
	    set maskSize(value: number[] | undefined);
	    /**
	     * 设置滤镜
	     */
	    get filter(): any;
	    set filter(value: any);
	    /**
	     * 设置鼠标样式
	     */
	    get cursor(): string;
	    set cursor(value: string);
	    /**
	     * 填充颜色，后面取代Color
	     * 数组形式 [r,g,b,a]
	     */
	    private _fillColor;
	    get fillColor(): number[] | number[][];
	    set fillColor(value: number[] | number[][]);
	    /**
	     * 支持：图形
	     * 边框线条颜色
	     * 数组形式 [r,g,b,a]
	     */
	    private _lineColor;
	    get lineColor(): number[];
	    set lineColor(value: number[]);
	    /**
	     * 支持：图形
	     * 边框线条宽度
	     */
	    private _lineWidth;
	    get lineWidth(): number;
	    set lineWidth(value: number);
	    /**
	     * 文本颜色
	     * 16进制RGB 0xffffff ｜ 16777215
	     * 数组形式 [r,g,b,a]
	     *
	     * 默认白色
	     * */
	    private _color?;
	    get color(): string | number | number[] | string[] | undefined;
	    set color(value: string | number | number[] | string[] | undefined);
	    /** 字符间距 */
	    private _letterSpacing?;
	    get letterSpacing(): number | undefined;
	    set letterSpacing(value: number | undefined);
	    /**
	     * 是否自动换行
	     * */
	    private _wordWrap;
	    get wordWrap(): boolean;
	    set wordWrap(value: boolean);
	    /**
	     * 自动换行的宽度
	     * */
	    private _wordWrapWidth?;
	    get wordWrapWidth(): any;
	    set wordWrapWidth(value: any);
	    /**
	     * 下划线类型
	     * */
	    private _textDecoration;
	    get textDecoration(): "None" | "Overline" | "LineThrough" | "UnderLine";
	    set textDecoration(value: "None" | "Overline" | "LineThrough" | "UnderLine");
	    /**
	    * 下划线颜色
	    * */
	    private _textDecorationColor;
	    get textDecorationColor(): number;
	    set textDecorationColor(value: number);
	    /**
	     * 多行文本(wordWrap = true) - 对齐方式
	     * */
	    private _textAlign;
	    get textAlign(): "left" | "right" | "center";
	    set textAlign(value: "left" | "right" | "center");
	    /**
	     * 多行文本(wordWrap = true) - 垂直对齐方式
	     * */
	    private _verticalAlign;
	    get verticalAlign(): "top" | "bottom" | "middle";
	    set verticalAlign(value: "top" | "bottom" | "middle");
	    /**
	     * 多行文本(wordWrap = true) - 行高
	     * */
	    private _lineHeight?;
	    get lineHeight(): number | undefined;
	    set lineHeight(value: number | undefined);
	    /** 字体 示例：fontFamily = "\"Comic Sans MS\", cursive, sans-serif" */
	    private _fontFamily?;
	    private _whiteFamily;
	    get fontFamily(): string | string[] | undefined;
	    set fontFamily(value: string | string[] | undefined);
	    /** 字体大小 */
	    private _fontSize;
	    get fontSize(): number;
	    set fontSize(value: number);
	    /** 字体样式 */
	    private _fontStyle;
	    get fontStyle(): "normal" | "italic" | "oblique";
	    set fontStyle(value: "normal" | "italic" | "oblique");
	    /**  字体变形，普通或小写  */
	    private _fontVariant;
	    get fontVariant(): "normal" | "small-caps";
	    set fontVariant(value: "normal" | "small-caps");
	    private _fontWeight;
	    /**
	     * 字体粗细
	     * 枚举 vf.gui.enum.FontWeight
	     * */
	    get fontWeight(): FontWeight;
	    set fontWeight(value: FontWeight);
	    /** 内部填充,只支持文字 */
	    private _padding?;
	    get padding(): number | undefined;
	    set padding(value: number | undefined);
	    /** 描边颜色 */
	    private _stroke?;
	    get stroke(): string | number | number[] | undefined;
	    set stroke(value: string | number | number[] | undefined);
	    /** 描边的笔触粗细值 */
	    private _strokeThickness;
	    get strokeThickness(): number;
	    set strokeThickness(value: number);
	    /** 是否设置投影 */
	    private _dropShadow;
	    get dropShadow(): boolean;
	    set dropShadow(value: boolean);
	    /** 投影的alpha值 */
	    private _dropShadowAlpha;
	    get dropShadowAlpha(): boolean;
	    set dropShadowAlpha(value: boolean);
	    /** 是否设置投影 */
	    private _dropShadowAngle;
	    get dropShadowAngle(): number;
	    set dropShadowAngle(value: number);
	    /** 投影的模糊半径 */
	    private _dropShadowBlur;
	    get dropShadowBlur(): number;
	    set dropShadowBlur(value: number);
	    /** 投影填充颜色值 */
	    private _dropShadowColor;
	    get dropShadowColor(): string | number | number[] | undefined;
	    set dropShadowColor(value: string | number | number[] | undefined);
	    /** 投影深度 */
	    private _dropShadowDistance;
	    get dropShadowDistance(): number;
	    set dropShadowDistance(value: number);
	    /**
	     * 渐变类型
	     *  0 = 垂直渐变
	     *  1 = 水平渐变
	     */
	    private _fillGradientType;
	    get fillGradientType(): 0 | 1;
	    set fillGradientType(value: 0 | 1);
	    /** 渐变区间 */
	    private _fillGradientStops;
	    get fillGradientStops(): number[];
	    set fillGradientStops(value: number[]);
	    /** 中文换行 */
	    private _breakWords;
	    get breakWords(): boolean;
	    set breakWords(value: boolean);
	}

}
declare module 'src/layout/CSSBasicLayout' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	export const $tempRectangle: vf.Rectangle;
	/**
	 * 布局尺寸>外部显式设置尺寸>测量尺寸 的优先级顺序返回尺寸
	 */
	export function formatRelative(value: number | string | undefined, total: number): number;
	/**
	 * @private
	 * 一个工具方法，使用BasicLayout规则布局目标对象。
	 */
	export function updateBasicDisplayList(target: DisplayObject | undefined, unscaledWidth: number, unscaledHeight: number): void;

}
declare module 'src/layout/CSSGridLayout' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 *  更新网格布局
	 *
	 * 单位目前只支持数值或百分比：100 ，”100%“
	 *
	 *  网格布局中，子容器的位置与宽高可能失效
	 *
	 * 关于grid布局的词汇表
	 *
	 * 格网 https://developer.mozilla.org/zh-CN/docs/Glossary/Grid
	 *
	 * 网格行 gridTemplateRows https://developer.mozilla.org/zh-CN/docs/Web/CSS/grid-template-columns
	 *
	 * 网格列 gridTemplateColumns https://developer.mozilla.org/zh-CN/docs/Web/CSS/grid-template-rows
	 *
	 * 网格行间距 gridRowGap   https://developer.mozilla.org/zh-CN/docs/Web/CSS/grid-row-gap
	 *
	 * 网格列间距 gridColumnGap  https://developer.mozilla.org/zh-CN/docs/Web/CSS/grid-column-gap
	 *
	 * 网格轴 （未实现） 支持居中方式为：justifyContent，alignContent
	 *
	 * 网格线（未实现） https://developer.mozilla.org/en-US/docs/Glossary/Grid_Lines
	 *
	 * 网格面积（未实现）https://developer.mozilla.org/zh-CN/docs/Glossary/Grid_Areas
	 */
	export function updateGridLayout(target: DisplayObject): vf.Rectangle;

}
declare module 'src/layout/CSSLayout' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { DisplayLayoutAbstract } from 'src/core/DisplayLayoutAbstract';
	export const $TempyAlignRectangle: vf.Rectangle;
	export const $TempLayoutRectangle: vf.Rectangle;
	export const $TempMeasureRectangle: vf.Rectangle;
	/**
	 * @private
	 * 一个工具方法，使用BasicLayout规则测量目标对象。
	 */
	export function measure(target: DisplayLayoutAbstract): void;
	/**
	 * 调整目标的元素的大小并定位这些元素。
	 */
	export function updateDisplayLayout(target: DisplayObject, unscaledWidth: number, unscaledHeight: number): void;

}
declare module 'src/core/plugs/UIBaseDrag' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { InteractionEvent } from 'src/interaction/Index';
	import { DisplayObjectAbstract } from 'src/core/DisplayObjectAbstract';
	import { Stage } from 'src/core/Stage';
	/**
	 *  组件的拖拽操作
	 *
	 */
	export class UIBaseDrag implements Lifecycle {
	    /**
	     * 构造函数
	     */
	    constructor(target: DisplayObject);
	    static key: string;
	    private target;
	    $targetParent: DisplayObject | Stage | undefined;
	    private oldInteractiveChildren;
	    /**
	     * 可拖动初始化
	     *  @default
	     */
	    private dragInitialized;
	    /**
	     * 可被掉落初始化
	     * @default
	    */
	    private dropInitialized;
	    /**
	     * 拖动控制类
	     */
	    private drag;
	    /**
	     * 临时属性，为了解决同步时的动作补齐
	     * 0 没有操作
	     * 1 开始拖动
	     * 2 拖动中
	     * 3 拖动结束
	     * 4 拖动到目标
	     */
	    private _dragState;
	    /**
	     * 位置
	     *
	     */
	    private _dragPosition;
	    /**
	     * 掉落容器的位置
	     */
	    private _dropPosition;
	    /**
	     * 开始的偏移量
	     */
	    private _startOffset;
	    /**
	     * 是否拖动中
	     * @default
	     */
	    dragging: boolean;
	    /**
	     * 当前拖动组件的事件ID，用于处理DragDropController中多组件的选定
	     */
	    get dragDropEventId(): number | undefined;
	    /**
	     * 是否开启拖动
	     * @default false
	     */
	    set draggable(value: boolean);
	    /**
	     * 是否碰撞检测
	     */
	    collision: boolean;
	    /**
	     * 是否设置边界
	     * @default false
	     */
	    dragBoundary: boolean;
	    /**
	     * 是否启用回弹，在移动到非接收方时，回弹到原始位置
	     */
	    dragBounces: boolean;
	    /**
	     * 拖拽时的鼠标状态
	     */
	    dragMoveCursor: string;
	    /**
	     * 限制拖动抽,XY,X抽或Y抽
	     */
	    private _dragRestrictAxis?;
	    get dragRestrictAxis(): "x" | "y" | undefined;
	    set dragRestrictAxis(value: "x" | "y" | undefined);
	    /**
	     * 拖动分组
	     */
	    get dragGroup(): string;
	    set dragGroup(value: string);
	    /**
	     * 拖动时，物体临时的存放容器，设置后，请注意事件流
	     */
	    private _dragContainer;
	    get dragContainer(): DisplayObjectAbstract | undefined;
	    set dragContainer(value: DisplayObjectAbstract | undefined);
	    /**
	     * 是否开启拖动掉落接收
	     */
	    set droppable(value: boolean | undefined);
	    /**
	     * 接收掉落的新容器
	     */
	    private _droppableReparent;
	    get droppableReparent(): DisplayObject | undefined;
	    set droppableReparent(value: DisplayObject | undefined);
	    /**
	     * 接收拖动掉落的分组名
	     */
	    private _dropGroup;
	    set dropGroup(value: string);
	    get dropGroup(): string;
	    protected clearDraggable(): void;
	    private oldWorldTransform;
	    private oldLocalTransform;
	    protected initDraggable(): void;
	    protected checkCollision(e: InteractionEvent): void;
	    protected checkBump(origin: vf.Rectangle, target: vf.Rectangle): boolean;
	    protected clearDroppable(): void;
	    protected initDroppable(): void;
	    onDrop(e: InteractionEvent): void;
	    /**
	     * 同步数据临时的方法
	     */
	    private executeDrop;
	    load(): void;
	    release(): void;
	}

}
declare module 'src/core/plugs/UIClick' {
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 *  组件的单击操作
	 *
	 */
	export class UIClick implements Lifecycle {
	    /**
	     * 构造函数
	     */
	    constructor(target: DisplayObject);
	    static key: string;
	    private _target;
	    private _clickEvent;
	    set double(value: boolean);
	    get double(): boolean;
	    load(): void;
	    release(): void;
	}

}
declare module 'src/core/plugs/HitArea' {
	import { DisplayObject } from 'src/core/DisplayObject';
	export class HitArea implements Lifecycle {
	    private _type;
	    private _x;
	    private _y;
	    private _width;
	    private _height;
	    private _sprite;
	    private _displayObj;
	    private _drawShape?;
	    /**
	     * 构造函数
	     */
	    constructor(target: DisplayObject);
	    static key: string;
	    get type(): "rect" | "ellipse";
	    set type(value: "rect" | "ellipse");
	    get x(): number;
	    set x(value: number);
	    get y(): number;
	    set y(value: number);
	    get width(): number;
	    set width(value: number);
	    get height(): number;
	    set height(value: number);
	    updataHitArea(): void;
	    private getHitArea;
	    load(): void;
	    release(): void;
	}

}
declare module 'src/core/DisplayObject' {
	///   types="@vf.js/vf" />
	import { DisplayLayoutAbstract } from 'src/core/DisplayLayoutAbstract';
	import { CSSStyle } from 'src/layout/CSSStyle';
	import { UIBaseDrag } from 'src/core/plugs/UIBaseDrag';
	import { HitArea } from 'src/core/plugs/HitArea';
	/**
	 * UI的顶级类，基础的UI对象
	 *
	 * @class
	 * @since 1.0.0
	 */
	export class DisplayObject extends DisplayLayoutAbstract implements Lifecycle {
	    /**
	     * 构造函数
	     */
	    constructor();
	    /**
	     * 插件列表
	     */
	    plugs: Map<string, Lifecycle>;
	    /**
	     * 拖动限制门槛,小于设置的数不执行拖动,防止点击与滚动
	     */
	    dragThreshold: number;
	    /** 拖动时，事件流是否继续传输 */
	    dragStopPropagation: boolean;
	    /** 模糊 */
	    private blurFilter?;
	    /** 子类实现 */
	    _anchorX: number;
	    /** 子类实现 */
	    _anchorY: number;
	    /**
	     * 设置拖动
	     */
	    get dragOption(): UIBaseDrag;
	    set dragOption(value: UIBaseDrag);
	    /** 是否开启鼠标或触摸点击，开启后，接收TouchMouseEvent */
	    get interactabled(): boolean;
	    set interactabled(value: boolean);
	    /**
	     * 设置拖拽
	     */
	    get hitArea(): HitArea;
	    checkHitArea(): boolean;
	    /** 是否开启鼠标或触摸点击，开启后，接收TouchMouseEvent */
	    get isClick(): boolean;
	    set isClick(value: boolean);
	    /**
	     * 分组
	     */
	    protected _groupName?: string;
	    get groupName(): string | undefined;
	    set groupName(value: string | undefined);
	    /**
	     * 透明度
	     */
	    get alpha(): number;
	    set alpha(value: number);
	    /**
	     * 色调
	     * @default 0xFFFFFF
	     * */
	    protected _tint: number;
	    get tint(): number;
	    set tint(value: number);
	    /**
	     * 混合模式
	     */
	    private _blendMode;
	    get blendMode(): vf.BLEND_MODES | undefined;
	    set blendMode(value: vf.BLEND_MODES | undefined);
	    private _filterProxy;
	    private _filterMap;
	    private _filterCount;
	    get filter(): any;
	    /**
	     * 设置Blur XY的模糊强度
	     *
	     * 参数类型为number时，设置 blurX = blurY = value
	     *
	     */
	    set filterBlur(value: number);
	    get filterBlur(): number;
	    /**
	     * 设置灰度
	     *
	     * 参数类型为 number, 接收一个百分比值，然后再将其转换为小数
	     */
	    private grayscaleFilter?;
	    private grayscaleFilterValue;
	    set filterGrayscale(value: number);
	    get filterGrayscale(): number;
	    /**
	     * 私有样式代理
	     * */
	    protected _style?: CSSStyle;
	    /**
	    *  在不同分辨率下保持像素稳定
	    * @default
	    */
	    pixelPerfect: boolean;
	    /**
	     * 动态属性，避免其他类注入
	     */
	    attach: {
	        [key: string]: object | number | string | Function;
	    };
	    /**
	     * 获取样式
	     */
	    get style(): CSSStyle;
	    set style(value: CSSStyle);
	    toDomRectangle(): vf.Rectangle;
	    /**
	     * 更新显示列表,子类重写，实现布局
	     */
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    load(): void;
	    release(): void;
	    releaseAll(): void;
	}

}
declare module 'src/utils/GraphicsUtils' {
	export function parseValues(args: any): any;
	export function vectorAngle(ux: any, uy: any, vx: any, vy: any): number;
	export function getArcCenter(px: number, py: number, cx: number, cy: number, rx: number, ry: number, largeArcFlag: number, sweepFlag: number, sinphi: number, cosphi: number, pxp: number, pyp: number): number[];
	export function approxUnitArc(ang1: number, ang2: number): {
	    x: number;
	    y: number;
	}[];
	export function mapToEllipse(data: {
	    x: number;
	    y: number;
	}, rx: number, ry: number, cosphi: number, sinphi: number, centerx: number, centery: number): {
	    x: number;
	    y: number;
	};
	export function arcToBezier(px: number, py: number, cx: number, cy: number, rx: number, ry: number, xAxisRotation?: number, largeArcFlag?: number, sweepFlag?: number): {
	    x1: number;
	    y1: number;
	    x2: number;
	    y2: number;
	    x: number;
	    y: number;
	}[];
	/**
	 * svg格式拆数组格式
	 * cmds
	(4) [Array(3), Array(8), Array(8), Array(1)]
	0: (3) ["M", 280, 250]
	1: (8) ["A", 200, 200, 0, 1, 1, 680, 250]
	2: (8) ["A", 200, 200, 0, 1, 1, 280, 250]
	3: ["Z"]
	length: 4
	 */
	export function parser(path: any): any;
	export function q2b(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): number[];
	/**
	 * 解析svg的path
	 *
	 *
	    M = moveto
	    L = lineto
	    H = horizontal lineto
	    V = vertical lineto
	    C = curveto
	    S = smooth curveto
	    Q = quadratic Belzier curve
	    T = smooth quadratic Belzier curveto
	    A = elliptical Arc
	    Z = closepath
	    以上所有命令均允许小写字母。大写表示绝对定位，小写表示相对定位(从上一个点开始)。
	 */
	export function parseSvgData(path: string): never[][];
	export function toSVGString(shapes: any): any;

}
declare module 'src/utils/ObjectPool' {
	 class ObjectPool {
	    constructor();
	    /**
	     * 作为对象池的词典dict
	     */
	    private objPoolDict;
	    /**
	     * 向对象池中放入对象，以便重复利用
	     */
	    push<T extends Lifecycle, S>(keyClass: S, oldObj: T): void;
	    /**
	     * 从对象池中取出需要的对象
	     * @return 取出的相应对象
	     *
	     */
	    pop<T>(keyClass: T): any;
	}
	/**
	 * 对象池实例
	 */
	export const objectPoolShared: ObjectPool;
	export {};

}
declare module 'src/utils/calculateUpdatePlayerSize' {
	///   types="@vf.js/vf" />
	import { Stage } from 'src/core/Stage';
	export const enum ScaleMode {
	    SHOW_ALL = "showAll",
	    NO_SCALE = "noScale",
	    COVER = "cover",
	    CONTAIN = "contain",
	    FIXEDHEIGHT = "fixedHeight",
	    FIXEDWIDTH = "fixedWidth"
	}
	export function getBoundingClientRect(dom: HTMLElement): DOMRect;
	/**
	 * @private
	 *
	 * 更新播放器视口尺寸
	 *
	 * noScale 不对内容进行任何缩放，保持原始的1:1比例。如果播放器窗口比内容小，则可能进行一些裁切。
	 *
	 * showAll 非溢出居中，显示全部内容。水平或垂直“两侧”可能会不够宽而留有黑边。
	 *
	 * contain 非溢出，显示全部内容，水平或垂直“一侧”方向有黑边。
	 *
	 * cover 溢出居中，某些部分也许无法显示在播放器视口。
	 */
	export function calculateUpdatePlayerSize(scrennDiv: HTMLElement, app: vf.Application, stage: Stage, stageW: number, stageH: number, scaleMode: ScaleMode): {
	    width: number;
	    height: number;
	    scaleX: number;
	    scaleY: number;
	};

}
declare module 'src/utils/setInteractiveElement' {
	/**
	 * 设置事件绑定目标
	 * @param stage
	 * @param parame
	 */
	export function setInteractiveElement(stage: vf.gui.Stage, parame: {
	    className: string;
	    defaultPointer: string;
	    htmlElement?: HTMLElement;
	    resolution?: number;
	}): void;

}
declare module 'src/utils/cacheDestroy' {
	export function cacheDestroy(res: any, bool: boolean): void;

}
declare module 'src/utils/Utils' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { Stage } from 'src/core/Stage';
	import { DisplayObjectAbstract } from 'src/core/DisplayObjectAbstract';
	export * from 'src/utils/ObjectPool';
	export * from 'src/utils/calculateUpdatePlayerSize';
	export * from 'src/utils/setInteractiveElement';
	export * from 'src/utils/cacheDestroy';
	/**
	 * 是否调试模式
	 */
	export let debug: boolean;
	/**
	 * 工具类
	 */
	/** 日志输出 */
	export function log(message?: string | number | object, ...optionalParams: string[] | number[] | object[]): void;
	/**
	 * 组件获取资源 - 源路径,外部可以重写本方法
	 */
	export let $getSourcePath: Function;
	export function setSourcePath(params: (path: any, cls?: any) => {}): void;
	/**
	 * 根据显示路径，获取显示对象
	 */
	export let $getUIDisplayObjectPath: Function;
	export function setDisplayObjectPath(params: (cls?: any, target?: DisplayObject) => {}): void;
	export function getSource(src: any): any;
	export function getTexture(src: any): any;
	export function getSheet(src: any): any;
	export function getSound(src: any): any;
	export function getDisplayObject(src: any, target?: DisplayObject): any;
	/**
	 * 递归获取舞台，组件必须已经添加到舞台
	 * @param DisplayObject
	 */
	export function getStage(target: DisplayObject | DisplayObjectAbstract | Stage): Stage | undefined;
	/**
	 * 获取显示对象的路径(解析json需要的id，并不是uuid)
	 * @param target
	 * @param ids
	 */
	export function getDisplayPathById(target: DisplayObject | DisplayObjectAbstract | Stage, ids?: string[]): string[];
	/**
	 * 快速设置矩形
	 * @param sourcr
	 * @param x
	 * @param y
	 * @param w
	 * @param h
	 */
	export function setRectangle(source: vf.Rectangle, x: number, y: number, w: number, h: number): void;
	/** 获取当前运行时时间 */
	export function now(): number;
	/**
	 * 深度拷贝对象
	 * @param source 对象元
	 */
	export function deepCopy(source: any, target?: any): any;
	/**
	 * helper function to convert string hex to int or default
	 *
	 * 16进制转int，颜色转换
	 * @param str 要转换的值，如#FFFFFF,0xFFFFFF
	 * @param def 转换失败的返回值
	 */
	export function hexToInt(str?: string | number, def?: any): any;
	/**
	 * helper function to convert string hex to int or default
	 *
	 * 16进制转int，颜色转换
	 * @param str 要转换的值，如#FFFFFF,0xFFFFFF
	 * @param def 转换失败的返回值
	 */
	export function hexListToIntList(str?: string | number | string[] | number[], def?: any): any;
	/**
	 *
	 * @param hex 16进制字符窜 如 #FFFFFF ，不能省略三位写法
	 * @param alpha 透明度
	 * @returns "rgba(255,255,255,1)" || false
	 */
	export function hexToRgba(hex: string, alpha: number): string | false;
	/**
	 * 转换为16位字符串，不够2位的补0，如 “01”
	 * @param c 要转换的数字
	 */
	export function componentToHex(c: number): string;
	/**
	 * RGB转16进制
	 * @param r 红 0-255
	 * @param g 绿 0-255
	 * @param b 蓝 0-255
	 */
	export function rgbToHex(r: number, g: number, b: number): string;
	/**
	 * RGB转number
	 * @param r 红 0-255
	 * @param g 绿 0-255
	 * @param b 蓝 0-255
	 */
	export function rgbToNumber(r: number, g: number, b: number): number;
	/**
	 * rgb字符串形式转换
	 * @param color rgb(255,255,255)
	 */
	export function rgbStrToNumber(color: string): number;
	/**
	 * 10进制转RGB
	 * @param c 数
	 */
	export function numberToRgb(c: number): {
	    r: number;
	    g: number;
	    b: number;
	};
	/**
	 * hex 转 RGB，
	 *
	 * 如hex字符串: "#ffffff"->255,255,255
	 *
	 * 如16进制数字: 0xffffff->255,255,255
	 * @param hex
	 */
	export function hexToRgb(hex?: string | number): {
	    r: number;
	    g: number;
	    b: number;
	};
	/**
	 * 根据amt计算当前的位置start-stop，两数差值
	 * @param start 开始数值
	 * @param stop  结束的数值
	 * @param amt 0-1 用时 >1为1，小于0为0
	 */
	export function Lerp(start: number, stop: number, amt: number): number;
	/**
	 * 四舍五入保留指定位数的小数
	 * @param num 取舍的数
	 * @param decimals 保留小数位
	 */
	export function Round(num: number, decimals: number): number;
	/** 获取全局唯一数 */
	export function uid(): number;
	/** 获取URL参数 */
	export function getQueryVariable(variable: string): string | null | undefined;
	/**
	 * 解析一个字符串函数的参数，如xxx(1) = 1
	 * @param
	 */
	export function getStringFunctionParam(str: string): {
	    key: string;
	    value: number;
	};
	export function isDeltaIdentity(m: vf.Matrix): boolean;
	/**
	 * 格式化一个百分比为小数
	 * @param value
	 * @param total
	 */
	export function formatRelative(value: number | string | undefined, total: number): number;
	/** 计算两点距离 */
	export function pointDistance(pointA: vf.Point | {
	    x: number;
	    y: number;
	}, pointB: vf.Point | {
	    x: number;
	    y: number;
	}): number;
	/** 坐标相减 */
	export function pointSub(source: vf.Point | {
	    x: number;
	    y: number;
	}, subPoint: vf.Point | {
	    x: number;
	    y: number;
	}): {
	    x: number;
	    y: number;
	};
	/** 坐标相加 */
	export function pointPlus(source: vf.Point | {
	    x: number;
	    y: number;
	}, PlusPoint: vf.Point | {
	    x: number;
	    y: number;
	}): {
	    x: number;
	    y: number;
	};
	/** 向量转弧度 */
	export function pointSignAngle(pointA: vf.Point | {
	    x: number;
	    y: number;
	}, pointB: vf.Point | {
	    x: number;
	    y: number;
	}): number;
	/**
	 *  根据类型获得具体的类定义
	 * @param type
	 */
	export function getGuiClass(type: string): any;
	export function sayHello(): void;
	/**
	 * 全局坐标转本地坐标
	 */
	export function toLocal(position: vf.IPoint, localDisplayObject: vf.DisplayObject | DisplayObjectAbstract): vf.Point;
	/**
	 * 本地坐标转全局坐标
	 */
	export function toGlobal(position: vf.IPoint, localDisplayObject: vf.DisplayObject | DisplayObjectAbstract): vf.Point;
	/**
	 * 本地坐标转全局
	 */
	export function toWorldTransform(localDisplayObject: vf.DisplayObject | DisplayObjectAbstract): vf.Matrix;
	export function toLoacalTransform(localDisplayObject: vf.DisplayObject | DisplayObjectAbstract): vf.Matrix;
	/**
	 * 本地显示对象转换到DIV坐标，核心是减去canvas的偏移量
	 * @param localDisplayObject
	 * @returns
	 */
	export function toDomRectangle(localDisplayObject: DisplayObjectAbstract | Stage, point?: vf.IPointData): vf.Rectangle;
	/**
	 * svgData to array
	 */
	export function path2shapes(path: string): never[][];
	/**
	 * array to svgData
	 */
	export function toSVGStr(shapes: any): any;
	export class ParseDataItem {
	    type: "M" | "L" | "Q" | "C";
	    x: number;
	    y: number;
	    ct1X: number;
	    ct1Y: number;
	    ct2X: number;
	    ct2Y: number;
	}
	/**
	 * 创建显示对象
	 * @param moduleName
	 * @param option
	 * @param parent
	 * example:
	 *   let img = vf.gui.Utils.createDisplayObject("Image", {x: 0, y: 0, src: 'xxxx.png'}, this) as vf.gui.Image;
	 */
	export function createDisplayObject(moduleName: string, option: any, parent?: DisplayObjectAbstract): any;

}
declare module 'src/core/Filter' {
	///   types="@vf.js/vf" />
	export class Filter extends vf.Filter {
	    static isFilter: boolean;
	    static defaultFilterVertex: string;
	    static list: Map<string, boolean>;
	    constructor(vertexSrc?: string, fragmentSrc?: string, uniforms?: {
	        [key: string]: any;
	    });
	}

}
declare module 'src/display/Slider' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { Image as VfuiImage } from 'src/display/Image';
	import { DragEvent, InteractionEvent } from 'src/interaction/Index';
	/**
	 * 滑动条/进度条
	 *
	 * @example let slider = new vf.gui.Slider();
	 *
	 */
	export class Slider extends DisplayObject {
	    constructor();
	    /**
	     * 当前值
	     */
	    protected _amt: number;
	    /**
	     * 小数的保留位，0不保留
	     * @default 0
	     */
	    protected _decimals: number;
	    protected _startValue: number;
	    protected _maxPosition: number;
	    protected _lastChange: number;
	    protected _lastChanging: number;
	    protected _localMousePosition: vf.Point;
	    /** 状态展示 */
	    readonly trackImg: VfuiImage;
	    readonly thumbImg: VfuiImage;
	    readonly tracklightImg: VfuiImage;
	    protected _thumbDrag: DragEvent;
	    protected _trackDrag: DragEvent;
	    /**
	     * 当前值
	     */
	    get value(): number;
	    set value(value: number);
	    protected valueSystem(value?: number): void;
	    /**
	     * 最小值
	     */
	    protected _minValue: number;
	    get minValue(): number;
	    set minValue(value: number);
	    /**
	     * 最大值
	     */
	    protected _maxValue: number;
	    get maxValue(): number;
	    set maxValue(value: number);
	    /**
	     * 是否垂直,滑块方向
	     */
	    protected _vertical: boolean;
	    get vertical(): boolean;
	    set vertical(value: boolean);
	    /**
	     * 背景
	     */
	    protected _track?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    get track(): string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined;
	    set track(value: string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined);
	    /**
	     * 手柄
	     */
	    protected _thumb?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    get thumb(): string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined;
	    set thumb(value: string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined);
	    /**
	     * 进度
	     */
	    protected _tracklight?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    get tracklight(): string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined;
	    set tracklight(value: string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined);
	    protected onImgload(): void;
	    protected updatePosition(soft?: boolean): void;
	    protected onPress(event: InteractionEvent, isPressed: boolean, dragEvent?: DragEvent): void;
	    protected onDragStart(event: InteractionEvent): void;
	    protected onDragMove(event: InteractionEvent, offset: vf.Point): void;
	    protected onDragEnd(event: InteractionEvent): void;
	    protected updatePositionToMouse(mousePosition: vf.Point, soft: boolean): void;
	    protected triggerValueChange(): void;
	    protected triggerValueChanging(): void;
	    updateLayout(): void;
	    protected commitProperties(): void;
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    release(): void;
	}

}
declare module 'src/display/ScrollBar' {
	///   types="@vf.js/vf" />
	import { Slider } from 'src/display/Slider';
	import { ScrollingContainer } from 'src/display/ScrollingContainer';
	import { Image } from 'src/display/Image';
	import { InteractionEvent } from 'src/interaction/Index';
	/**
	 * UI 带有滚动条的容器
	 */
	export class ScrollBar extends Slider {
	    constructor();
	    /**
	     * 是的自动隐藏滚动条
	     */
	    autohide: boolean;
	    private _scrollingContainer;
	    private _hidden;
	    protected toggleHidden(hidden: boolean): void;
	    protected onThumbLoadComplete(rectangle: vf.Rectangle, source: Image): void;
	    protected triggerValueChanging(): void;
	    private _source;
	    get source(): ScrollingContainer | string | undefined;
	    set source(value: ScrollingContainer | string | undefined);
	    private _dragScrolling;
	    get dragScrolling(): boolean;
	    set dragScrolling(value: boolean);
	    protected commitProperties(): void;
	    protected alignToContainer(): void;
	    protected onDragMove(event: InteractionEvent, offset: vf.Point): void;
	    protected updatePosition(soft?: boolean): void;
	    release(): void;
	}

}
declare module 'src/display/ScrollingContainer' {
	///   types="@vf.js/vf" />
	import { Container } from 'src/display/Container';
	import { ContainerBase } from 'src/core/ContainerBase';
	import { DisplayObjectAbstract } from 'src/core/DisplayObjectAbstract';
	/**
	 * 可滚动的容器
	 *
	 * @example let scrollingContainer = new vf.gui.ScrollingContainer();
	 *
	 */
	export class ScrollingContainer extends Container {
	    constructor();
	    /**
	     * 是否启动拖拽滚动
	     * @default true
	     */
	    private _dragScrolling;
	    get dragScrolling(): boolean;
	    set dragScrolling(value: boolean);
	    /**
	     * 滚动的阻力或柔度 (0-1)
	     * @default 0.5
	     */
	    softness: number;
	    /**
	     * 滚动条的圆角半径 设置0时，滚动条为直角长方形
	     * @default 0
	     */
	    radius: number;
	    private scrollMask;
	    /**
	     * 遮罩的扩充范围
	     */
	    expandMask: number;
	    /**
	     * 是否开启滚动动画
	     * @default false
	     */
	    animating: boolean;
	    /**
	     * 是否启用水平滚动
	     * @default false
	     */
	    scrollX: boolean;
	    /**
	     * 是否滚动中
	     */
	    scrollY: boolean;
	    /**
	     * 内容容器
	     * @private
	     */
	    private _innerContainer;
	    /**
	     * 内容的宽高
	     */
	    innerBounds: vf.Rectangle;
	    /**
	     * 拖动处理类
	     */
	    private dragEvent?;
	    /**
	     * 鼠标滚动
	     */
	    private mouseScrollEvent?;
	    /**
	     * 是否滚动中
	     */
	    private scrolling;
	    /**
	     * 临时方案，设置时间间隔，跳转容器宽高
	     */
	    private _boundCached;
	    private _lastWidth;
	    private _lastHeight;
	    private _isInitScrolling;
	    private _containerStart;
	    private _targetPosition;
	    private _lastPosition;
	    private _Position;
	    private _Speed;
	    private _stop;
	    private isInitDrag;
	    protected initDrag(): void;
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    protected setScrollPosition(speed?: vf.Point): void;
	    get innerContainer(): ContainerBase;
	    addChild<T extends DisplayObjectAbstract>(item: T): T;
	    addChildAt<T extends DisplayObjectAbstract>(item: T, index: number): T;
	    getInnerBounds(force?: boolean): vf.Rectangle;
	    $onInit(): void;
	    protected initScrolling(): void;
	    protected updateScrollBars(): void;
	    /**
	     * 百分比设置位置
	     * @param direction 方向
	     * @param pct 百分比0-1
	     */
	    forcePctPosition(direction: "x" | "y", pct: number): void;
	    /** 根据焦点设置位置 */
	    focusPosition(pos: vf.Point): void;
	    protected updateScrollPosition(delta: number): void;
	    protected updateDirection(direction: "x" | "y", delta: number): void;
	    release(): void;
	}

}
declare module 'src/display/SpriteAnimated' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 * 序列图动画
	 *
	 * 支持使用texturepacker导出以及处理轴点
	 *
	 * @example let spriteAnimated = new vf.gui.SpriteAnimated();
	 *
	 */
	export class SpriteAnimated extends DisplayObject {
	    constructor();
	    private _animatedSprites;
	    private _lastAnimatedName;
	    private _curFrameNumber;
	    private _setTimeoutId;
	    /**
	     * 要播放的动作名
	     */
	    private _animationName;
	    get animationName(): string;
	    set animationName(value: string);
	    /**
	     * 序列图路径，或序列图数组
	     */
	    private _src;
	    get src(): vf.Spritesheet | vf.Texture[] | vf.AnimatedSprite.FrameObject[] | undefined;
	    set src(value: vf.Spritesheet | vf.Texture[] | vf.AnimatedSprite.FrameObject[] | undefined);
	    /**
	     * 动画速度
	     */
	    private _animationSpeed;
	    get animationSpeed(): number;
	    set animationSpeed(value: number);
	    /**
	     * 是的循环
	     */
	    private _loop;
	    get loop(): boolean;
	    set loop(value: boolean);
	    private _playCount;
	    /**
	     * 循环次数
	     */
	    private _loopCount;
	    get loopCount(): number;
	    set loopCount(value: number);
	    /**
	     * 是否播放中
	     */
	    private _playing;
	    get playing(): boolean;
	    /**
	     * 锚点，调整位图的坐标中点 0-1, 可通过 TexturePacker输出sheet图并设置好 anchor
	     */
	    get anchorX(): number;
	    set anchorX(value: number);
	    /**
	     * 锚点，调整位图的坐标中点 0-1, 可通过 TexturePacker输出sheet图并设置好 anchor
	     */
	    get anchorY(): number;
	    set anchorY(value: number);
	    /** 跳转到第N帧并播放 */
	    gotoAndPlay(frameNumber: number): void;
	    /** 跳转到第N帧并停止 */
	    gotoAndStop(frameNumber: number): void;
	    /** 停止 */
	    stop(): void;
	    /** 播放 */
	    play(): void;
	    /**
	     * 请在构造函数后立即设置
	     */
	    get autoPlay(): boolean;
	    set autoPlay(value: boolean);
	    set isPlay(value: boolean);
	    /**
	     * 添加动画
	     */
	    addAnimated(animationName: string, textures: vf.Texture[] | vf.AnimatedSprite.FrameObject[]): void;
	    release(): void;
	    protected releaseAnimate(): void;
	    protected srcSystem(): void;
	    protected animatedNameSystem(): void;
	    protected playSystem(): void;
	    protected attribSystem(): void;
	}

}
declare module 'src/event/KeyEvent' {
	/**
	 * 键盘事件 驱动类KeysEvent
	 *
	 */
	export const enum KeyEvent {
	    input = "input",
	    /**
	     * 键盘按下
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    keydown = "keydown",
	    /**
	     * 键盘弹起
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    keyup = "keyup",
	    /**
	     * 粘贴
	     *
	     * (e:InteractionEvent,obj:DisplayObject,clipboardData: DataTransfer | null)
	     */
	    paste = "paste",
	    /**
	     * 复制
	     *
	     * (e:InteractionEvent,obj:DisplayObject,clipboardData: DataTransfer | null)
	     */
	    copy = "copy",
	    /**
	     * 剪切
	     *
	     * (e:InteractionEvent,obj:DisplayObject,clipboardData: DataTransfer | null)
	     */
	    cut = "cut",
	    /**
	     * 回退删除
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    backspace = 8,
	    /**
	     * 回车
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    enter = 13,
	    /**
	     * 删除
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    delete = 46,
	    /**
	     * 全选 ctrl+a
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    ctrlA = 65,
	    /**
	     * 撤销 ctrl+z
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    ctrlZ = 90,
	    /**
	     * 箭头左
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    left = 37,
	    /**
	     * 箭头上
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    top = 38,
	    /**
	     * 箭头右
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    right = 39,
	    /**
	     * 箭头下
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    down = 40,
	    /**
	     * shift + 箭头左
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    shiftLeft = "shift37",
	    /**
	     * shift + 箭头右
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    shiftRight = "shift39",
	    /**
	     * shift + 箭头上
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    shiftTop = "shift38",
	    /**
	     * shift + 箭头下
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    shiftDown = "shift40"
	}

}
declare module 'src/display/private/HtmlInput' {
	///   types="@vf.js/vf" />
	/**
	 * 私有的，由于VFJS不支持文本输入，这里以HTML方式实现
	 */
	export default class HtmlInput extends vf.utils.EventEmitter {
	    constructor(multiline: boolean);
	    private _domInput;
	    private _selection;
	    private _restrictRegex;
	    private _restrictValue;
	    get domInput(): HTMLInputElement | HTMLTextAreaElement;
	    set visible(value: boolean);
	    get visible(): boolean;
	    get value(): string;
	    set value(value: string);
	    set placeholder(value: string);
	    set disabled(value: boolean);
	    get maxlength(): number;
	    set maxlength(value: number);
	    get restrict(): RegExp | undefined;
	    set restrict(regex: RegExp | undefined);
	    setStyle(style: InputStyle): void;
	    setStyleValue(key: any, value: any): void;
	    select(): void;
	    /** 测量，需要对象添加到body中 */
	    getDOMInputBounds(): DOMRect;
	    updatePostion(top: string | number, left: string | number, transform: string, opacity?: string | number): void;
	    private addDom;
	    private removeDom;
	    release(): void;
	    private _onInputKeyDownBind;
	    private _onInputInputBind;
	    private _onInputKeyUpBind;
	    private _onFocusedBind;
	    private _onBlurredBind;
	    private addEvent;
	    private removeEvent;
	    private _applyRestriction;
	    private _onInputKeyDown;
	    private _onInputInput;
	    private _onInputKeyUp;
	    private _onFocused;
	    private _onBlurred;
	    focus(): void;
	    blur(): void;
	}

}
declare module 'src/display/TextInput' {
	///   types="@vf.js/vf" />
	import HtmlInput from 'src/display/private/HtmlInput';
	import { InputBase } from 'src/display/private/InputBase';
	import { Image } from 'src/display/Image';
	/**
	 * 文本输入
	 *
	 * @example let textInput = new vf.gui.TextInput(true|false);//单行或多行
	 *
	 */
	export class TextInput extends InputBase {
	    constructor(multiline?: boolean);
	    protected _oldState: string;
	    protected htmlInputShared: HtmlInput;
	    protected _lastRenderer: vf.Renderer | undefined;
	    protected _resolution: number;
	    protected _canvasBounds: {
	        top: number;
	        left: number;
	        width: number;
	        height: number;
	    } | undefined;
	    protected _previous: {
	        canvasBounds: any;
	        worldTransform: any;
	        worldAlpha: any;
	        worldVisible: any;
	    } | any;
	    protected _inputStyle: InputStyle;
	    /**
	     * 预览文字的样式
	     */
	    protected placeholderColor: number;
	    protected _domVisible: boolean;
	    protected _textHitbox: vf.Graphics;
	    protected _textMask: vf.Graphics;
	    protected _text: vf.Text;
	    protected _fontMetrics: vf.IFontMetrics | undefined;
	    protected state: string;
	    /**
	     * 设置文本
	     */
	    get text(): string;
	    set text(value: string);
	    /**
	     * 预览文字
	     */
	    private _placeholder;
	    get placeholder(): string;
	    set placeholder(value: string);
	    /**
	     * 设置最大可输入
	     */
	    private _maxLength;
	    get maxLength(): number;
	    set maxLength(value: number);
	    /**
	     * 过滤表达式
	     */
	    private _restrict;
	    get restrict(): RegExp | undefined;
	    set restrict(value: RegExp | undefined);
	    /**
	     * 状态展示
	    */
	    readonly img: Image;
	    updateSystem(renderer?: vf.Renderer): void;
	    /**
	     * 设置焦点
	     */
	    focus(): void;
	    /**
	     * 失去焦点
	     */
	    blur(): void;
	    /**
	     * 设置css style样式
	     * @param key 健
	     * @param value 值
	     */
	    setInputStyle(key: any, value: any): void;
	    protected onStateChange(ui: TextInput, state: string): void;
	    private _onInputInput;
	    private _onFocused;
	    private _onBlurred;
	    private _setState;
	    private _updateSubstitution;
	    render(renderer: vf.Renderer): void;
	    private _renderInternal;
	    private _updateDOMInput;
	    private _needsUpdate;
	    private _updatetext;
	    private _ontextFocus;
	    private _ensureFocus;
	    private _derivetextStyle;
	    private _derivetextPadding;
	    private _derivetextText;
	    private _hasFocus;
	    private _getCanvasBounds;
	    private _getDOMRelativeWorldTransform;
	    private _vfMatrixToCSS;
	    private _comparevfMatrices;
	    private _compareClientRects;
	    release(): void;
	}

}
declare module 'src/display/Polygon' {
	import { GraphBase } from 'src/display/private/GraphBase';
	export class Polygon extends GraphBase {
	    constructor();
	    private path;
	    private PI_2;
	    private _triangleNum;
	    private RADIUS_V;
	    drawGraph(): void;
	    get triangleNum(): number;
	    set triangleNum(value: number);
	    private setStarPath;
	}

}
declare module 'src/display/Arrow' {
	import { GraphBase } from 'src/display/private/GraphBase';
	export class Arrow extends GraphBase {
	    constructor();
	    private _angle;
	    drawGraph(): void;
	    private getArrowPath;
	}

}
declare module 'src/display/Ellipse' {
	import { GraphBase } from 'src/display/private/GraphBase';
	/**
	 * 绘制椭圆
	 *
	 * 不设置 lineWidth 或 color 椭圆不可见
	 *
	 */
	export class Ellipse extends GraphBase {
	    constructor();
	    drawGraph(): void;
	}

}
declare module 'src/display/Isosceles' {
	import { GraphBase } from 'src/display/private/GraphBase';
	/**
	 * 等腰梯形和等腰三角形(上边长度为0)
	 *
	 * 梯形上边的中点为中心点
	 *
	 * 不设置 lineWidth 或 color 矩形不可见
	 *
	 */
	export class Isosceles extends GraphBase {
	    constructor();
	    private _upLine;
	    private _downLine;
	    private _path;
	    get upLine(): number;
	    set upLine(value: number);
	    get downLine(): number;
	    set downLine(value: number);
	    drawGraph(): void;
	    private setIsosPath;
	}

}
declare module 'src/display/Graphics' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { GraphicsCore } from 'src/display/private/GraphicsCore';
	/**
	 * 矢量绘制
	 *
	 * @example let graphics = new vf.gui.Graphics();
	 *
	 */
	export class Graphics extends DisplayObject {
	    constructor(geometry?: vf.GraphicsGeometry | undefined);
	    readonly graphics: GraphicsCore;
	}

}
declare module 'src/display/private/selectedBounds' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	export enum BoundsEventType {
	    boundsScale = "boundsScale",
	    boundsAngle = "boundsAngle",
	    selectedBoundsClicked = "selectedBoundsClicked"
	}
	export class SelectedBounds extends DisplayObject {
	    constructor();
	    private _boundsRect?;
	    private _selectedRect?;
	    private _lastPos;
	    private _bounds;
	    private _uiContainer?;
	    private _cornerContainer?;
	    private onMove;
	    /**
	     * 向量的夹角
	     */
	    private measureAngle;
	    /**
	     * 添加选中时的8个小方块
	     */
	    private addSelectedShapeRect;
	    private getBoundsPosList;
	    /**
	     * 显示
	     */
	    show(parent: DisplayObject, bounds: vf.Rectangle, scaleX?: number, scaleY?: number, angle?: number, showCorner?: boolean): void;
	    /**
	     * 更新
	     */
	    update(parent: DisplayObject, bounds: vf.Rectangle, scaleX?: number, scaleY?: number, angle?: number, showCorner?: boolean): void;
	    /**
	     * 隐藏
	     */
	    hide(): void;
	}

}
declare module 'src/display/FollowLine' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { InteractionEvent } from 'src/interaction/Index';
	import { FollowLineEnum } from 'src/enum/Index';
	/**
	 * 跟随鼠标或触摸绘制线条
	 *
	 * @example let graphics = new vf.gui.FollowLine();
	 *
	 */
	export class FollowLine extends DisplayObject {
	    constructor();
	    /** 线条 */
	    private _lines;
	    /** 触摸的ID */
	    private _touchId;
	    /** 位置缓存，记录画线时候每一个点，最后画完优化 */
	    private _posCache;
	    /** 保存已画线的key */
	    private _lineKeys;
	    /** 鼠标坐标 */
	    private _mouseOffset;
	    /** 上次点击坐标 */
	    private _lastPos;
	    /**
	     * 划线索引, 取时间戳
	     */
	    private _curLineIndex;
	    /**
	     * 需要处理的消息列表
	     */
	    private _messageCache;
	    /**
	     * 线条颜色
	     */
	    lineColor: number;
	    /**
	     * 线条宽度
	     */
	    lineWidth: number;
	    /**
	     * 是否暂停，一些特殊情况，如拖拽时，可暂停
	     */
	    isPause: boolean;
	    /**
	     * LINES instead of TRIANGLE_STRIP
	     */
	    private lineType;
	    /**
	     * 是否启用橡皮檫
	     */
	    isErasing: boolean;
	    /** 角色状态 */
	    role: FollowLineEnum.Role;
	    /** 选择框的容器  */
	    private _selectedBounds?;
	    /** 要删除的线，复制品 */
	    private _eraseLine?;
	    set eraseLine(value: vf.Graphics | undefined);
	    get eraseLine(): vf.Graphics | undefined;
	    /**
	     * @private
	     * 提交属性，子类在调用完invalidateProperties()方法后，应覆盖此方法以应用属性
	     */
	    protected commitProperties(): void;
	    /**
	     * 更新显示列表,子类重写，实现布局
	     */
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    /**
	     * 添加选择框
	     */
	    private addSelectedBound;
	    private onMessage;
	    private addEvent;
	    private removeEvent;
	    onPress(e: InteractionEvent, thisObj: DisplayObject, isPress: boolean): void;
	    onMove(e: InteractionEvent): void;
	    /**
	     * 发送操作事件
	     * @param operate   1添加 2删除 3重置
	     * @param role  Role
	     * @param lineIndex 线段 ID
	     */
	    private emitMsg;
	    /**
	     *
	     * @param name (name = role + lineId)
	     * @param role
	     */
	    private getGraphics;
	    private getCurLineByPos;
	    private getDataStrByPosCache;
	    private drawLine;
	    private removeLine;
	    clear(): void;
	    setData(data: string | string[]): void;
	    reset(): any;
	    release(): void;
	}

}
declare module 'src/display/ConnectLine' {
	import { DisplayObject } from 'src/core/DisplayObject'; type LinePostion = 'leftTop' | 'centerTop' | 'rightTop' | 'leftCenter' | 'center' | 'rightCenter' | 'leftBottom' | 'centerBottom' | 'rightBottom' | number[];
	export const play: unique symbol;
	/**
	 * 连线组件
	 *
	 *
	 * @example let connectLine = new vf.gui.ConnectLine();
	 *
	 */
	export class ConnectLine extends DisplayObject {
	    constructor();
	    private readonly line;
	    private _lastStartPos;
	    private _lastEndPos;
	    private _play;
	    private _tw?;
	    /**
	     *  触发画线操作
	     *
	     *  属性 play = 1 触发画线，线条从source->target.
	     *  属性 play = 2 触发画线，线条从target->source.
	     */
	    get play(): 2 | 1;
	    set play(value: 2 | 1);
	    private _autoPlay;
	    /**
	     *  默认 autoPlay = true
	     *
	     *  autoPlay = true时，组件在设置source,target,sourcePostion,targetPostion后自动触发画线，线条从source->target.
	     *
	     *  autoPlay = false时，设置source,target,sourcePostion,targetPostion后不会触发画线，需调用 play.
	     */
	    get autoPlay(): boolean;
	    set autoPlay(value: boolean);
	    private _source?;
	    /**
	     * 设置源显示对象
	     */
	    get source(): DisplayObject | undefined;
	    set source(value: DisplayObject | undefined);
	    private _sourcePostion;
	    /**
	     * 设置源显示对象位置
	     */
	    get sourcePostion(): LinePostion;
	    set sourcePostion(value: LinePostion);
	    private _target?;
	    /**
	     * 设置目标显示对象
	     */
	    get target(): DisplayObject | undefined;
	    set target(value: DisplayObject | undefined);
	    private _targetPostion;
	    /**
	     * 设置目标显示对象位置
	     */
	    get targetPostion(): LinePostion;
	    set targetPostion(value: LinePostion);
	    /**
	     * 线条颜色
	     */
	    private _lineColor;
	    get lineColor(): number;
	    set lineColor(value: number);
	    /**
	     * 线条粗细
	     */
	    private _lineWidth;
	    get lineWidth(): number;
	    set lineWidth(value: number);
	    private _isAnimation;
	    /**
	     * 线条位置改变时，是否有动画
	     */
	    get isAnimation(): boolean;
	    set isAnimation(value: boolean);
	    private _speed;
	    /**
	     * 设置获取连线速度
	     */
	    get speed(): number;
	    set speed(value: number);
	    protected commitProperties(): void;
	    private getLocalPos;
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    private animation;
	    set isClear(value: boolean);
	    clear(): void;
	    release(): void;
	}
	export {};

}
declare module 'src/display/Tracing' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { ClickEvent } from 'src/interaction/Index';
	import { TracingEnum } from 'src/enum/Index';
	export class Tracing extends DisplayObject {
	    constructor();
	    protected clickEvent: ClickEvent;
	    private _renderMode;
	    private _guideSprite;
	    private _bgSprite;
	    private _lines;
	    private _realTraceIndexArr;
	    private _tempTraceIndexArr;
	    private _lineStyle;
	    private _posCache;
	    private _drawing;
	    private _lastLocalPos;
	    private _curLocalPos;
	    private _autoComplete;
	    private _curIndex;
	    private _tracePointObjArr;
	    private _result;
	    private _groupStatusArr;
	    private _lineId;
	    private _newLineFlag;
	    private _pointId;
	    private _messageCache;
	    private _tween;
	    private _guideTime;
	    private _strictFlag;
	    private _fillIndex;
	    /**
	     * debug
	     */
	    private _debug;
	    get debug(): boolean;
	    set debug(value: boolean);
	    /**
	     * 模式
	     */
	    private _mode;
	    set mode(value: TracingEnum.Mode);
	    get mode(): TracingEnum.Mode;
	    /**
	     * 文字轨迹图
	     */
	    private _traceSprite;
	    get traceSprite(): string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined;
	    set traceSprite(value: string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined);
	    /**
	     * 背景图，mask模式用于画线后漏出来
	     */
	    private _renderBgSprite;
	    get renderBgSprite(): string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined;
	    set renderBgSprite(value: string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined);
	    /**
	     * 轨迹点,二维数组
	     */
	    private _tracePoints;
	    get tracePoints(): {
	        x: number;
	        y: number;
	    }[][];
	    set tracePoints(value: {
	        x: number;
	        y: number;
	    }[][]);
	    /**
	     * 线宽
	     */
	    private _lineWidth;
	    get lineWidth(): number;
	    set lineWidth(value: number);
	    /**
	     * 颜色
	     */
	    private _lineColor;
	    get lineColor(): number;
	    set lineColor(value: number);
	    /**
	     * 检测精度
	     */
	    private _precision;
	    get precision(): number;
	    set precision(value: number);
	    /**
	     * 位图
	     */
	    private _lineTexture;
	    get lineTexture(): string | number | undefined;
	    set lineTexture(value: string | number | undefined);
	    /**
	     * 线透明度
	     */
	    private _lineOpacity;
	    get lineOpacity(): number | undefined;
	    set lineOpacity(value: number | undefined);
	    /**
	     * 画笔样式
	     */
	    private setLineStyle;
	    /**
	     * 轨迹图
	     */
	    private setTraceSprite;
	    /**
	     * mask背景图
	     */
	    private setRenderBgSprite;
	    /**
	     * 移出mask背景图
	     */
	    private removeRenderBgSprite;
	    /**
	     * 开始，适用于audo和teach模式
	     */
	    private start;
	    /**
	     * 教学引导
	     */
	    private guide;
	    private playGuideAnimal;
	    /**
	     * 清除教学引导
	     */
	    clearGuide(): void;
	    /**
	     * 自动绘制
	     */
	    private auto;
	    private _posLength;
	    private drawWithAnimation;
	    private autoNextPoint;
	    /**
	     * 更新显示列表,子类重写，实现布局
	     */
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    $onInit(): void;
	    $onRelease(): void;
	    /**
	     * 检测触摸点和轨迹点
	     * @param point
	     */
	    private checkTrace;
	    /**
	     * 检查暂存区,抬起时检测暂存区中的点是否在一个笔画上
	     */
	    private checkTemp;
	    /**
	     * 检查group
	     */
	    private checkResult;
	    private checkStrictFirstPoint;
	    private checkStrict;
	    private checkFill;
	    /**
	     * 教学模式检查
	     */
	    private checkTeach;
	    /**
	     * 画线
	     * @param lineId
	     * @param data
	     * @param from
	     * @param to
	     * @param lineStyle
	     */
	    private drawLine;
	    /**
	     * 绘图
	     * @param graphics
	     * @param posList
	     */
	    private draw;
	    /**
	     * 本地绘制
	     * @param graphics
	     */
	    private localDraw;
	    private onPress;
	    private onMove;
	    /**
	     *
	     * @param lineId
	     * @param lineStyle
	     */
	    private getGraphics;
	    private getDataStrByPosCache;
	    /**
	     * 发送一个笔画的msg
	     * @param lineId
	     * @param data
	     */
	    private emitTracingMsg;
	    private onMessage;
	    removeLine(lineId: string): void;
	    /**
	     * clear
	     */
	    clear(): void;
	    /**
	     * @private
	     * 提交属性，子类在调用完invalidateProperties()方法后，应覆盖此方法以应用属性
	     */
	    protected commitProperties(): void;
	    setData(data: string | string[]): void;
	    set source(data: string | string[]);
	}

}
declare module 'src/display/animation/Timeline' {
	export class Timeline<T> {
	    set defaultValue(value: T);
	    get curValue(): T;
	    set globalTime(v: number);
	    frames: Array<Frame<T>>;
	    private curTime;
	    lastTime: number;
	    loop: boolean;
	    totalTime: number;
	    protected _defaultValue: T;
	    protected _globalTime: number;
	    protected _lastGlobalTime: number;
	    protected _lastFrame: Frame<T> | null;
	    protected _curFrame: Frame<T> | null;
	    protected _nextFrame: Frame<T>;
	    protected _times: number;
	    protected _curValue: T;
	    constructor();
	    protected getProgress(cur: number, min: number, max: number, ease: ((k: number) => number) | any): number;
	    protected tick(): void;
	    protected updateCurFrame(): void;
	    protected updateCurValue(): void;
	    release(): void;
	}
	export class Frame<T> {
	    time: number;
	    ease?: ((k: number) => number) | any;
	    value: T;
	    getValue(progress: number, value: T): T;
	}
	export class NumberFrame extends Frame<number> {
	    constructor();
	    getValue(progress: number, value: number): number;
	}

}
declare module 'src/display/animation/PathTimeline' {
	import { Timeline } from 'src/display/animation/Timeline';
	export class PathTimeline extends Timeline<number> {
	    private path;
	    private length;
	    constructor(path: string);
	    get curPos(): [number, number];
	    get angle(): number;
	    release(): void;
	}

}
declare module 'src/display/animation/AnimationPath' {
	import { AnimationBase } from 'src/display/private/AnimationBase';
	export class AnimationPath extends AnimationBase {
	    private pathTimeline?;
	    constructor(sp?: any, options?: any, duratime?: number);
	    play(timer?: number): void;
	    gotoAndStop(timer: number): void;
	    protected updata(delta: number): void;
	    release(): void;
	}

}
declare module 'src/display/animation/Animation' {
	export class Animation {
	    private static _aniList;
	    static play(type: string, sprite: any, options: any, durtime?: number, callBack?: Function): any;
	    private static removeItem;
	    static releaseAll(): void;
	}

}
declare module 'src/display/private/AnimationBase' {
	///   types="@vf.js/vf" />
	export class AnimationBaseData {
	    x: number;
	    y: number;
	    rotation: number;
	}
	export class AnimationBase extends vf.utils.EventEmitter {
	    private _sprite;
	    protected _spriteData?: AnimationBaseData;
	    private _options;
	    private _duratime;
	    protected _currenTimer: number;
	    protected _revertAni: boolean;
	    private _playing;
	    private _valuesStart;
	    protected _toValue: any;
	    private _addTick;
	    constructor(sp?: any, options?: any, duratime?: number);
	    get playing(): boolean;
	    get sprite(): any;
	    set sprite(value: any);
	    get options(): any;
	    set options(value: any);
	    get revertAni(): boolean;
	    protected cacheSprite(): void;
	    play(curTimer?: number): void;
	    pause(): void;
	    /**
	     * 播放完成
	     */
	    complete(): void;
	    gotoAndPlay(timer: number): void;
	    gotoAndStop(timer: number): void;
	    /**
	     * 跳转
	     */
	    goto(timer: number): void;
	    /**
	     *
	     * 设置当前sprite状态
	     */
	    private setTimeStates;
	    /**
	     * 获取当前时间的sprite数据
	     * 如果重播时重头播放就可以  子类可以不用重写
	     *  每个动画计算方式不同 这个方法需要重写
	     */
	    getTimeData(timer: number): AnimationBaseData | undefined;
	    /**
	     *
	     */
	    protected updata(delta: number): void;
	    release(): void;
	}

}
declare module 'src/display/animation/AnimationJitter' {
	import { AnimationBase } from 'src/display/private/AnimationBase';
	export class AnimationJitter extends AnimationBase {
	    private tween;
	    constructor(sp?: any, options?: any, duratime?: number);
	    play(timer?: number): void;
	    gotoAndStop(timer: number): void;
	    private clearTween;
	    complete(): void;
	    release(): void;
	}

}
declare module 'src/interaction/AudioGroupController' {
	import { Audio } from 'src/display/Audio';
	interface AudioGroupObject {
	    groups: {
	        [key: string]: {
	            [value: string]: Audio;
	        };
	    };
	    values: {
	        [key: string]: string | undefined;
	    };
	}
	export const _audioGroupObject: AudioGroupObject;
	export function registrerAudioGroup(cb: Audio): void;
	/**
	 * 注销指定分组或指定分组的子项
	 * @param cb video
	 */
	export function unRegistrerAudioGroup(cb: Audio): void;
	/** 更新分组中选中的checkbox组件  */
	export function updateAudioGroupStates(cb: Audio): void;
	export {};

}
declare module 'src/display/Audio' {
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 * 音频组件
	 *
	 * 准备完成 canplaythrough
	 *
	 * 播放事件 play
	 *
	 * 暂停事件 pause
	 *
	 * 错误事件 error
	 *
	 * 播放时间改变 timeupdate
	 *
	 * 播放完成 ended
	 *
	 * @example let audio = new vf.gui.Audio();
	 *
	 *
	 */
	export enum PlayerStates {
	    init = "init",
	    play = "play",
	    pause = "pause",
	    end = "end"
	}
	export class Audio extends DisplayObject {
	    private audio?;
	    private _id;
	    private _src;
	    private _autoplay;
	    private _loop;
	    private _playbackRate;
	    private _volume;
	    private _audioUid;
	    private _playerStates;
	    private stoping;
	    constructor();
	    set audioUid(value: string);
	    private initAudio;
	    /**
	    * 设置src 支持3种 url base64 arraybuffer;
	    */
	    set src(value: any);
	    get src(): any;
	    set autoplay(value: boolean);
	    get autoplay(): boolean;
	    set loop(value: boolean);
	    get loop(): boolean;
	    set playbackRate(value: number);
	    get playbackRate(): number;
	    set volume(value: number);
	    get volume(): number;
	    get duration(): number;
	    get paused(): boolean;
	    /**
	    * 设置分组名
	    */
	    get audioGroup(): string | undefined;
	    set audioGroup(value: string | undefined);
	    get playerStates(): PlayerStates;
	    get isPlaying(): boolean;
	    /**
	    * 支持的方法们~~~··~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	    *    */
	    /**
	     * 声音播放接口
	     *
	     *  await sound.play()
	     * @param {number} [time] - 声音延迟开始
	     * @param {number} [offset] - 声音的开始偏移值
	     * @param {number} [length] - 声音持续时间（以秒为单位）
	     */
	    play(time?: number, offset?: number, length?: number): void;
	    /**
	    * 停止声音
	    * @param time (optional) X秒后停止声音。默认情况下立即停止
	    */
	    stop(time?: number): void;
	    /**
	    * 暂停声音
	    */
	    pause(): void;
	    /**
	    * 释放
	    */
	    dispose(): void;
	    release(): void;
	    /**
	    * 各种可取参数.~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	    */
	    protected commitProperties(): void;
	    private useNativeAudio;
	    private nativeEmit;
	}

}
declare module 'src/event/SchedulerEvent' {
	export const enum SchedulerEvent {
	    /**
	     * 心跳
	     */
	    TICK = "tick",
	    /**
	     * 启动/开始
	     */
	    START = "start",
	    /**
	     * 更新
	     */
	    UPDATE = "update",
	    /**
	     * 结束
	     */
	    END = "end"
	}

}
declare module 'src/event/Index' {
	import * as ComponentEvent from 'src/event/ComponentEvent';
	import { InteractionEvent } from 'src/event/InteractionEvent';
	import { TouchMouseEvent } from 'src/event/TouchMouseEvent';
	import { TweenEvent } from 'src/event/TweenEvent';
	import { SchedulerEvent } from 'src/event/SchedulerEvent';
	export { ComponentEvent, InteractionEvent, TouchMouseEvent, TweenEvent, SchedulerEvent };

}
declare module 'src/display/PathGraphics' {
	import { GraphBase } from 'src/display/private/GraphBase';
	export enum ArrowType {
	    None = 0,
	    HollowCircle = 1,
	    FullCircle = 2,
	    HollowRect = 3,
	    FullRect = 4,
	    HollowArrow = 5,
	    FullArrow = 6,
	    line = 7
	}
	/**
	 * 矢量绘制
	 *
	 * @example let graphics = new vf.gui.Graphics();
	 *
	 */
	export class PathGraphics extends GraphBase {
	    constructor();
	    private _path;
	    private _pathData;
	    private _beginPort;
	    private _endPort;
	    private _graphicsBegin;
	    private _graphicsEnd;
	    private _beginRotation;
	    private _endRotation;
	    private _isSvgPath;
	    get path(): string;
	    set path(value: string);
	    get beginPort(): ArrowType;
	    set beginPort(value: ArrowType);
	    get endPort(): ArrowType;
	    set endPort(value: ArrowType);
	    drawGraph(): void;
	    private getType;
	    /**
	     * 新的解析方式
	     */
	    private drawInfoData;
	    private drawBeginPort;
	    private drawEndPort;
	    private drawShape;
	    /**
	  * svg格式线条 解析
	  *
	  * M 表示MoveTo
	   *   L 表示LineTo，
	   *   Q表示二次贝塞尔曲线
	   *   C 表示三次贝塞尔曲线
	  */
	    release(): void;
	}

}
declare module 'src/display/Alert' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { DisplayLayoutAbstract } from 'src/core/DisplayLayoutAbstract';
	export interface ButtonInfo {
	    btnNormal?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    btnHover?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    btnPressed?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    text?: string;
	}
	export class Alert extends DisplayObject {
	    static show(container: DisplayLayoutAbstract, content: string, textAlign?: string, duration?: number, icon?: number | string | vf.Texture, title?: string, buttons?: string[], x?: number, y?: number): Alert;
	    constructor();
	    /**
	     * 弹框标题
	     */
	    private _title;
	    set title(value: string);
	    get title(): string;
	    /**
	     * 弹框内容
	     */
	    private _content;
	    set content(value: string);
	    get content(): string;
	    /**
	     * 按钮内容
	     */
	    private _buttons;
	    set buttons(value: string[]);
	    get buttons(): string[];
	    private _imgButtons;
	    set imgButtons(value: ButtonInfo[]);
	    get imgButtons(): ButtonInfo[];
	    /**
	     * 自动弹出
	     */
	    autoShow: boolean;
	    /**
	     * 自动释放
	     */
	    autoRelease: boolean;
	    /**
	     * 持续时间
	     */
	    duration: number;
	    /**
	     * 内容对齐方式  //left  center
	     */
	    textAlign: string;
	    /**
	     * 按钮默认宽高
	     */
	    buttonWidth: number;
	    buttonHeight: number;
	    /**
	     * 背景遮罩颜色透明度
	     */
	    maskColor: number;
	    maskOpacity: number;
	    /**
	     * 皮肤样式
	     */
	    icon?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    background?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    btnNormal?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    btnHover?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    btnPressed?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    backgroundColor: number;
	    titleColor: number;
	    contentColor: number;
	    btnColors: number[];
	    btnTextColors: number[];
	    /**
	     * 显示状态
	     */
	    private _isShowing;
	    /**
	     * 组件显示对象
	     */
	    private _bgDisplay?;
	    private _titleDisplay?;
	    private _lineDisplay?;
	    private _contentDisplay?;
	    private _iconDisplay?;
	    private _buttonsDisplays;
	    protected commitProperties(): void;
	    /**
	     * 初始化显示
	     */
	    private initDisplay;
	    private _updateDisplayList;
	    /**
	     * 显示弹出框
	     */
	    show(): void;
	    /**
	     * 关闭弹出框
	     */
	    close(): void;
	    /**
	     * 释放
	     */
	    release(): void;
	    private onHover;
	    private onPress;
	    private onClick;
	}

}
declare module 'src/display/AutoContainer' {
	import { DisplayObjectAbstract } from 'src/core/DisplayObjectAbstract';
	import { Scheduler } from 'src/core/Scheduler';
	import { TimeLine } from 'src/tween/TimeLine';
	import { Tween } from 'src/tween/Tween';
	import { Container } from 'src/display/Container';
	/**
	 * 自动容器，提供各种组件的构造接口， timeline、tween、schedule的自动释放
	 * 手写代码构建scene的最佳实践：
	 * class Scene extends vf.gui.AutoContainer{
	 *
	 * }
	 */
	export class AutoContainer extends Container {
	    constructor();
	    private idCountDict;
	    private timeLineList;
	    private tweenList;
	    private schedulerList;
	    createDisplayObject(moduleName: string, option: any, parent?: DisplayObjectAbstract): any;
	    createTimeLine(option: any): TimeLine;
	    createTween(object: any): Tween;
	    setTimeout(time: number, callFunc: (data?: any) => void): Scheduler;
	    setInterval(time: number, callFunc: (data?: any) => void): Scheduler;
	    setEnterFrame(callFunc: (data?: any) => void): Scheduler;
	    release(): void;
	}

}
declare module 'src/UI' {
	///   types="@vf.js/vf" />
	/** 工具类 */
	import * as Utils from 'src/utils/Utils';
	/** UI舞台，最顶级的层 展示所有UI组件 */
	import { Stage } from 'src/core/Stage';
	/** UI基础显示对象，一般不会直接使用，只作为类型推断 */
	import { DisplayObject } from 'src/core/DisplayObject';
	/** 心跳，需要在初始化完成后，启动心跳更新 */
	import { TickerShared } from 'src/core/Ticker';
	/** 滤镜的基础类 */
	import { Filter } from 'src/core/Filter';
	/**
	 * 基础容器
	 *
	 * 设置checkGroup后，进行分组。 分组后，可理解为复选框。
	 *
	 * @example let container = new vf.gui.Container();
	 *
	 */
	import { Container } from 'src/display/Container';
	/**
	 * 滚动容器
	 *
	 * @example let scrollingContainer = new vf.gui.ScrollingContainer();
	 *
	 */
	import { ScrollingContainer } from 'src/display/ScrollingContainer';
	/**
	 * 图片
	 *
	 * @example let image = new vf.gui.Image();
	 *
	 *
	 */
	import { Image } from 'src/display/Image';
	/**
	 * 序列图动画
	 *
	 * 支持使用texturepacker导出以及处理轴点
	 *
	 * @example let spriteAnimated = new vf.gui.SpriteAnimated();
	 *
	 */
	import { SpriteAnimated } from 'src/display/SpriteAnimated';
	/**
	 * 文本
	 *
	 * 中文换行特殊处理 xxxx.style.breakWords = true;
	 *
	 * 文本没有宽高，自适应
	 *
	 * @example let label = new vf.gui.Label();
	 *
	 *
	 */
	import { Label } from 'src/display/Label';
	/**
	 * 文本输入
	 *
	 * @example let textInput = new vf.gui.TextInput(true|false);//单行或多行
	 *
	 *
	 */
	import { TextInput } from 'src/display/TextInput';
	/**
	 * 滑动条/进度条
	 *
	 * @example let slider = new vf.gui.Slider();
	 *
	 */
	import { Slider } from 'src/display/Slider';
	/**
	 * 按钮
	 *
	 * @example let button = new vf.gui.Button();
	 *
	 */
	import { Button } from 'src/display/Button';
	/**
	 * 单选\复选框
	 *
	 * 设置checkGroup后，进行分组。 分组后，可理解为复选框。
	 *
	 * @example let checkBox = new vf.gui.CheckBox();
	 *
	 *
	 */
	import { CheckBox } from 'src/display/CheckBox';
	/**
	 * 绘制矩形或圆角矩形
	 *
	 * @example let rect = new vf.gui.Rect();
	 *
	 *
	 */
	import { Rect } from 'src/display/Rect';
	/**
	 * 绘制矩形或圆角矩形
	 *
	 * @example let rect = new vf.gui.Circle();
	 *
	 *
	 */
	import { Circle } from 'src/display/Circle';
	/**
	 * 星型绘制
	 *
	 */
	import { Star } from 'src/display/Star';
	/**
	 * 多边形绘制
	 *
	 */
	import { Polygon } from 'src/display/Polygon';
	/**
	 * 箭头绘制
	 *
	 */
	import { Arrow } from 'src/display/Arrow';
	/**
	 * 椭圆绘制
	 *
	 */
	import { Ellipse } from 'src/display/Ellipse';
	/**
	 * 等腰绘制
	 *
	 */
	import { Isosceles } from 'src/display/Isosceles';
	/**
	 * 矢量绘制
	 *
	 * @example let graphics = new vf.gui.Graphics();
	 *
	 *
	 */
	import { Graphics } from 'src/display/Graphics';
	/**
	 * 跟随划线（鼠标或触摸按下时）
	 *
	 * @example let graphics = new vf.gui.FollowLine();
	 *
	 *
	 */
	import { FollowLine } from 'src/display/FollowLine';
	import { Video } from 'src/display/Video';
	/**
	 * 连线组件
	 *
	 *
	 * @example let connectLine = new vf.gui.ConnectLine();
	 *
	 *
	 */
	import { ConnectLine } from 'src/display/ConnectLine';
	/**
	 * 临摹组件
	 *
	 * @example let Tracing = new vf.gui.Tracing();
	 *
	 */
	import { Tracing } from 'src/display/Tracing';
	/**
	 * 滚动组件
	 *
	 * @example let scrollBar = new vf.gui.ScrollBar();
	 *
	 *
	 */
	import { ScrollBar } from 'src/display/ScrollBar';
	/**
	 * 完整的缓动曲线列表
	 *
	 * @example vf.gui.Easing.Linear.None;
	 *
	 *
	 */
	import { Easing } from 'src/tween/Easing';
	/**
	 * 缓动动画
	 *
	 * @example let tween = new vf.gui.Tween(myObject).to({width:'300px'}, 2000).start()
	 *
	 *
	 */
	import { Tween } from 'src/tween/Tween';
	/**
	 * 动画时间轴
	 */
	/**
	 * 振动动画
	 */
	import { AnimationJitter } from 'src/display/animation/AnimationJitter';
	import { Animation } from 'src/display/animation/Animation';
	import { NumberFrame } from 'src/display/animation/Timeline';
	/**
	 * 基于帧的时间轴控制类
	 *
	 * @example let timeline = new vf.gui.Timeline();
	 *
	 *
	 */
	import { TimeLine } from 'src/tween/TimeLine';
	/**
	 * 音频
	 *
	 *
	 *
	 * 估计是能播放  没毛病
	 *
	 * @example let audio = new vf.gui.Audio(“地址或者是arrbuffer”);
	 *
	 *
	 */
	import { Audio } from 'src/display/Audio';
	/**
	 * 事件绑定类，非继承于inputbase的组件是没有任何交互事件，需单独绑定
	 */
	import * as Interaction from 'src/interaction/Index';
	/**
	 * 事件名
	 */
	import * as Event from 'src/event/Index';
	/**
	 * 枚举
	 */
	import * as Enum from 'src/enum/Index';
	import { Scheduler } from 'src/core/Scheduler';
	import { SyncManager } from 'src/interaction/SyncManager';
	/**
	 *  路线绘制
	 */
	import { PathGraphics } from 'src/display/PathGraphics';
	import { Alert } from 'src/display/Alert';
	/**
	 * 自动容器
	 */
	import { AutoContainer } from 'src/display/AutoContainer';
	export type Application = vf.Application;
	/** 请不要在编写UI组件内部使用本类 */
	export { Audio, Filter, Utils, Stage, Container, AutoContainer, ScrollingContainer, Slider, Label, TextInput, Button, Video, CheckBox, Rect, Circle, Star, Arrow, Ellipse, Isosceles, Graphics, FollowLine, Tracing, ConnectLine, ScrollBar, Polygon, Interaction, DisplayObject, TickerShared, Tween, TimeLine, Easing, Image, SpriteAnimated, Event, Enum, Scheduler, NumberFrame, PathGraphics, AnimationJitter, Animation, SyncManager, Alert, };

}
declare module 'src/vf-gui' {
	import * as gui from 'src/UI';
	export { gui };

}
declare interface ObjectConstructor {
    assign(...objects: Record<string, any>[]): Record<string, any>;
}
interface ArrayConstructor {
    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
    from<T>(arrayLike: ArrayLike<T>): T[];
}
interface String {
    startsWith(searchString: string, position?: number): boolean;
}
interface TInputBase {
    blur?: Function;
    focus?: Function;
}
interface InputStyle {
    [propName: string]: any;
    fontFamily: string;
    fontSize?: string;
    fontWeight?: string;
    fontVariant: "normal" | "small-caps" | "inherit";
    color: '#000000';
    padding: string;
    multiline: boolean;
    fontStyle: "normal" | "italic" | "oblique" | "inherit";
    letterSpacing: number;
    textIndent: string;
    position: 'absolute';
    background: 'none';
    border: 'none';
    outline: 'none';
    transformOrigin: '0 0';
    lineHeight: '1';
}
interface Lifecycle {
    /**
     * 组件加载，暂时可能用不到
     */
    load(): void;
    /**
     * 释放，回收
     */
    release(): void;
}
/**
 * 生命周期的接口
 */
interface LifecycleHook {
    /**
     * 显示对象初始化完成，只执行一次,子类重写，不可外部调用
     */
    $onInit(): void;
    /**
     * 加载完成，不可外部调用
     */
    $onLoad(): void;
    /**
     * 回收，释放完成，不可外部调用
     */
    $onRelease(): void;
    /**
     * 添加到舞台后，不可外部调用
     */
    $onAddStage(): void;
    /**
     * 移出舞台后，不可外部调用
     */
    $onRemoveStage(): void;
}
declare module 'src/core/UIBase' {
	import { DisplayObject } from 'src/core/DisplayObject';
	export class UIBase extends DisplayObject implements Lifecycle {
	    constructor();
	}

}
declare module 'src/display/Pasition' {
	export class PasitionOptions {
	    from: any;
	    to: any;
	    duration: number;
	    mustSvgData?: boolean | undefined;
	    easing?: ((k: number) => number) | any;
	    onStart?: Function;
	    onUpdate?: Function;
	    onEnd?: Function;
	}
	export class Pasition {
	    private MIM_CURVES_COUNT;
	    private _beginTime;
	    private _pathArr;
	    private _pathB;
	    private _options?;
	    constructor(option?: PasitionOptions);
	    get from(): any;
	    set from(value: any);
	    get to(): any;
	    set to(value: any);
	    get duration(): number;
	    set duration(value: number);
	    get onStart(): Function | undefined;
	    set onStart(value: Function | undefined);
	    get onUpdate(): Function | undefined;
	    set onUpdate(value: Function | undefined);
	    get onEnd(): Function | undefined;
	    set onEnd(value: Function | undefined);
	    get easing(): any;
	    set easing(value: any);
	    get options(): PasitionOptions;
	    /**
	     * 动画初始值
	     */
	    play(): void;
	    /**
	     * 刷新
	     */
	    private onUpdata;
	    private _lerp;
	    private lerpCurve;
	    private lerpPoints;
	    /**
	     * 保持线条长度和关键点数相同
	     */
	    private _preprocessing;
	    private _splitCurves;
	    private split;
	    private _split;
	    private sync;
	    /**
	     * 取移动点最短距离的方案
	     */
	    private sort;
	    private boxDistance;
	    private sortCurves;
	    private permuteCurveNum;
	    private curveDistance;
	    private shapeBox;
	    private permuteNum;
	    private permute;
	    release(): void;
	}

}
declare module 'src/enum/ComponentEvent' {
	/**
	 * 特定属性改变时,通常为了去系统事件区分，UI组件的事件名为大写
	 * 1. CheckBox 的 checked 改变时
	 * 2. Label 的 text 改变时
	 * 3. SpriteAnimated 的 animationName 改变时
	 * 4. Button 文字改变
	 * 5. ScrollingContainer 拖动改变时
	 * 6. Slider 滑动改变后
	 * 7. SpriteAnimated 动画改变后
	 * 8. ConnectLine 连线完成时
	 * 9. Tracing 临摹完成一个笔画
	 */
	export const CHANGE = "CHANGE";
	/**
	 * 状态改变中
	 *
	 * slider 滑动时
	 */
	export const CHANGEING = "CHANGEING";
	/**
	 * 状态切换完成时
	 *
	 * 1. SpriteAnimated 每次播放完时，触发(loop = false时)
	 * 2. Image 图片加载完成时
	 * 3. Slider 滑动完成
	 * 4. Timeline  每次播放完时，触发(loop = false时)
	 * 5. FollowLine 完成一次划线
	 * 6. Tracing 临摹全部完成
	 */
	export const COMPLETE = "COMPLETE";
	/**
	 * 状态发生改变时
	 */
	export const STATE_CHANGE = "STATE_CHANGE";
	/**
	 * 状态切换完成时
	 *
	 * SpriteAnimated 每次播放完时，，触发(loop = true时)
	 */
	export const LOOP = "LOOP";
	/**
	 * 组件被添加前
	 */
	export const ADD = "add";
	/**
	 * 组件被添加时
	 */
	export const ADDED = "added";
	/**
	 * 组件被移除时
	 */
	export const REMOVEED = "removed";
	/**
	 * 组件大小改变后
	 */
	export const RESIZE = "RESIZE";
	/**
	 * 组件位置移动
	 */
	export const MOVE = "MOVE";
	/**
	 * 组件创建完成后
	 */
	export const CREATION_COMPLETE = "CREATION_COMPLETE";
	/**
	 * 组件拖动开始之前
	 */
	export const DRAG_START_BEFORE = "DRAG_START_BEFORE";
	/**
	 * 组件拖动开始时
	 */
	export const DRAG_START = "DRAG_START";
	/**
	 * 组件拖动结束之前
	 */
	export const DRAG_END_BEFORE = "DRAG_END_BEFORE";
	/**
	 * 组件拖动结束时 （如果绑定接收容器并拖动到接收容器中，不会触发此事件）
	 */
	export const DRAG_END = "DRAG_END";
	/**
	 * 组件拖动中
	 */
	export const DRAG_MOVE = "DRAG_MOVE";
	/**
	 * 组件拖动到接收目标中之前
	 */
	export const DRAG_TARGET_BEFORE = "DRAG_TARGET_BEFORE";
	/**
	 * 组件拖动到接收目标中
	 */
	export const DRAG_TARGET = "DRAG_TARGET";
	/**
	 * 有拖拽物掉落到此容器时触发
	 */
	export const DROP_TARGET = "DROP_TARGET";
	/**
	 * 播放音效 {name,mode}
	 */
	export const PLAY_AUDIO = "PLAY_AUDIO";

}
declare module 'src/interaction/KeyboardEvent' {
	import { DisplayObject } from 'src/core/DisplayObject'; class KeyboardSelectEvent {
	    /**
	     * document的键盘事件
	    */
	    constructor();
	    private obj;
	    private ctrlDown;
	    private shiftDown;
	    private shiftKey;
	    private ctrlKey;
	    private cmdKey;
	    private isAddEvent;
	    private keyDownEventBind;
	    private keyUpEventBind;
	    private pasteEventBind;
	    private copyEventBind;
	    private cutEventBind;
	    private addEvent;
	    private removeEvent;
	    protected keyDownEvent(e: KeyboardEvent): void;
	    protected keyUpEvent(e: KeyboardEvent): void;
	    protected copyEvent(e: ClipboardEvent): void;
	    protected cutEvent(e: ClipboardEvent): void;
	    protected pasteEvent(e: ClipboardEvent): void;
	    focus(obj: DisplayObject): void;
	    blur(): void;
	}
	/**
	 * KeyboardSelectEvent 的实例
	 */
	export const keyboardShared: KeyboardSelectEvent;
	export {};

}
declare module 'src/tween/private/PlaybackPosition' {
	/**
	 * 回放位置的相关操作函数
	 */
	export default class PlaybackPosition {
	    constructor();
	    private totalTime;
	    private labels;
	    private offsets;
	    parseLabel(_name: string, offset: string | number | null): number;
	    addLabel(_name: string, offset: string | number | null): this;
	    setLabel(_name: string, offset: string | number | null): this;
	    eraseLabel(_name: string, offset: string | number | null): this;
	}

}
declare module 'src/interaction/TouchMouseEventEnum' {
	/**
	 * 鼠标点击与触摸事件枚举,内部DisplayObject使用
	 * @since 1.0.0
	 */
	export const enum TouchMouseEventEnum {
	    mousedown = "mousedown",
	    mousemove = "mousemove",
	    mouseup = "mouseup",
	    mouseover = "mouseover",
	    mouseout = "mouseout",
	    mouseupoutside = "mouseupoutside",
	    mouseRightDown = "rightdown",
	    mouseRightup = "rightup",
	    mouseRightupoutside = "rightupoutside",
	    touchstart = "touchstart",
	    touchcancel = "touchcancel",
	    touchend = "touchend",
	    touchendoutside = "touchendoutside",
	    touchmove = "touchmove",
	    tap = "tap"
	}

}
declare module 'src/event/InteractionEvent' {
	///   types="@vf.js/vf" />
	/**
	 * 事件的基础类
	 *
	 * 触摸或鼠标操作事件 可查看 -> TouchEventEnum.TouchEnum
	 *
	 * import InteractionEvent from "../interaction/InteractionEvent",
	 */
	export class InteractionEvent extends vf.InteractionEvent {
	    constructor();
	    local: vf.Point;
	    path?: number[];
	    signalling: boolean;
	}

}
declare module 'src/event/TouchMouseEvent' {
	/**
	 * 对外，封装的点击触摸事件
	 *
	 * import InteractionEvent,{Mouse} from "../interaction/InteractionEvent",
	 */
	export const TouchMouseEvent: {
	    /**
	     * 移出
	     *
	     * (e: InteractionEvent,thisObj:DisplayObject,over: boolean)=>{}
	     */
	    onHover: string;
	    /**
	     * 按下
	     *
	     * (e: InteractionEvent,thisObj:DisplayObject, isPressed: boolean)=>void
	     */
	    onPress: string;
	    /**
	     * 按下
	     */
	    onDown: string;
	    /**
	     * 弹起
	     */
	    onUp: string;
	    /**
	     * 点击
	     *
	     * (e: InteractionEvent,thisObj:DisplayObject)=>void
	     */
	    onClick: string;
	    /**
	     * PC 特有，右键点击
	     *
	     * (e: InteractionEvent,thisObj:DisplayObject)=>void
	     */
	    onRightDown: string;
	    /**
	     * 移动
	     *
	     * (e: InteractionEvent,thisObj:DisplayObject)=>void
	     */
	    onMove: string;
	    /**
	     * 鼠标移入
	     *
	     * (e: InteractionEvent,thisObj:DisplayObject)=>void
	     */
	    onMouseEnter: string;
	    /**
	     * 鼠标移出
	     *
	     * (e: InteractionEvent,thisObj:DisplayObject)=>void
	     */
	    onMouseLeave: string;
	};

}
declare module 'src/tween/Easing' {
	/**
	 * 完整的缓动曲线列表
	 *
	 * @example vf.gui.Easing.Linear.None;
	 *
	 */
	export const Easing: {
	    Linear: {
	        None(k: number): number;
	    };
	    Quadratic: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Cubic: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Quartic: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Quintic: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Sinusoidal: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Exponential: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Circular: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Elastic: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Back: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Bounce: {
	        In(k: number): number;
	        Out(k: number): number;
	        InOut(k: number): number;
	    };
	    Stepped: {
	        steps: (steps: number) => (k: number) => number;
	    };
	};

}
declare module 'src/tween/private/constants' {
	/**
	 * 卡帧后的平滑处理帧率
	 */
	export const FRAME_MS: number;
	/**
	 * 平滑处理允许的触发时间
	 */
	export const TOO_LONG_FRAME_MS = 250;
	/**
	 * 链式补间动画的key前缀
	 */
	export const CHAINED_TWEENS = "_chainedTweens";
	export const STRING_PROP = "STRING_PROP";
	export const NUM_REGEX: RegExp;
	export function decomposeString(fromValue: string | any): any;
	export function decompose(prop: any, obj: any, from: any, to: any): any;
	export const RGB = "rgb(";
	export const RGBA = "rgba(";
	export function isRGBColor(v: any, i: number, r?: string): boolean;
	export function recompose(prop: any, obj: any, from: any, to: any, t: any, originalT: any, stringBuffer?: any): any;
	export const SET_NESTED: (nested: any) => any;

}
declare module 'src/tween/private/Interpolation' {
	/**
	 * 差值计算列表
	 * @example
	 *
	 * let bezier = vf.gui.tween.Interpolation.Bezier
	 * new vf.gui.tween.Tween({x:0}).to({x:[0, 4, 8, 12, 15, 20, 30, 40, 20, 40, 10, 50]}, 1000).interpolation(bezier).start()
	 * @memberof vf.gui.tween
	 */
	export const Interpolation: {
	    Linear(v: any, k: number, value: any): any;
	    Bezier(v: any, k: number, value: any): any;
	    CatmullRom(v: any, k: number, value: any): any;
	    Utils: {
	        Linear(p0: any, p1: any, t: any, v: any): any;
	        Reset(value: any): any;
	        Bernstein(n: any, i: any): number;
	        Factorial: (n: any) => number;
	        CatmullRom(p0: any, p1: any, p2: any, p3: any, t: any, v?: any): any;
	    };
	};

}
declare module 'src/event/TweenEvent' {
	/**
	 * 缓动事件
	 */
	export const TweenEvent: {
	    /**
	     *
	     */
	    Callback: string;
	    /**
	     * 每次改变
	     */
	    update: string;
	    /**
	     * 完成
	     */
	    complete: string;
	    /**
	     * 开始时
	     */
	    start: string;
	    /**
	     * 每次重复时
	     */
	    repeat: string;
	    /**
	     * 反向时
	     */
	    reverse: string;
	    /**
	     * 暂停时
	     */
	    pause: string;
	    /**
	     * 播放时
	     */
	    play: string;
	    /**
	     * 重新开始时
	     */
	    restart: string;
	    /**
	     * 停止时
	     */
	    stop: string;
	};

}
declare module 'src/tween/Tween' {
	///   types="@vf.js/vf" />
	import { add, get, getAll, remove, removeAll, removeDisplay, update } from 'src/tween/private/core';
	/**
	 * 缓动动画
	 *
	 * @example let tween = new vf.gui.Tween(myObject).to({width:'300px'}, 2000).start()
	 *
	 */
	export class Tween extends vf.utils.EventEmitter {
	    static core: {
	        add: typeof add;
	        get: typeof get;
	        getAll: typeof getAll;
	        remove: typeof remove;
	        removeAll: typeof removeAll;
	        removeDisplay: typeof removeDisplay;
	        update: typeof update;
	    };
	    static Event: {
	        Callback: string;
	        update: string;
	        complete: string;
	        start: string;
	        repeat: string;
	        reverse: string;
	        pause: string;
	        play: string;
	        restart: string;
	        stop: string;
	    };
	    /**
	     * Easier way to call the Tween
	     * @param {object} object - Initial value
	     * @param {object} to - Target value
	     * @param {object} params - Options of tweens
	     * @example Tween.fromTo(myObject, {x:0}, {x:200},1000)
	     * @memberof vf.gui.Tween
	     * @static
	     */
	    static fromTo(object: any, to: any, duration?: number): Tween;
	    /**
	     * Easier way calling constructor only applies the `to` value, useful for CSS Animation
	     * @param {any} object object
	     * @param {object} to - Target value
	     * @param {object} params - Options of tweens
	     * @example Tween.to(myObject, {x:200}, 1000)
	     * @memberof vf.gui.Tween
	     * @static
	     */
	    static to(object: any | any[], to: any, duration?: number): Tween;
	    /**
	     * Easier way calling constructor only applies the `from` value, useful for CSS Animation
	     * @param {any} object object
	     * @param {object} from - Initial value
	     * @param {object} params - Options of tweens
	     * @example Tween.from(myObject, {x:200}, 1000)
	     * @memberof vf.gui.Tween
	     * @static
	     */
	    static from(object: any, from: any, duration?: number): Tween;
	    constructor(object?: any);
	    id: number;
	    object: any;
	    private _valuesEnd;
	    private _valuesStart;
	    _virtualValueStart: any;
	    protected _duration: number;
	    private _easingFunction;
	    private _easingReverse;
	    private _interpolationFunction;
	    protected _startTime: number;
	    protected _delayTime: number;
	    private _repeat;
	    private _initRepeat;
	    _isPlaying: boolean;
	    private _yoyo;
	    private _reversed;
	    private _onStartCallbackFired;
	    private _isFinite;
	    private _prevTime;
	    private _rendered;
	    private _reverseDelayTime;
	    /** 附加数据 */
	    data: {
	        [key: string]: any;
	    };
	    /**
	     *
	     * 外部使用回调函数   这里用于timeLine给每个tween设置事件回调
	     */
	    onUpdate?: Function;
	    onUpdateParams?: any;
	    onStart?: Function;
	    onStartParams?: any;
	    onComplete?: Function;
	    onCompleteParams?: any;
	    onRepeat?: Function;
	    onRepeatParams?: any;
	    onReverseComplete?: Function;
	    onReverseCompleteParams?: any;
	    private _needDownGrade;
	    setObject(object: any): void;
	    onFunction(eventType: string, object: any, elapsed?: any): void;
	    get needDownGrade(): boolean;
	    set needDownGrade(value: boolean);
	    /**
	     * 是否在播放中
	     * @return {boolean}
	     * @example tween.isPlaying()
	     * @memberof vf.gui.Tween
	     */
	    get isPlaying(): boolean;
	    set isPlaying(value: boolean);
	    get valuesEnd(): any;
	    get valuesStart(): any;
	    /**
	     * 是否开始播放
	     * @return {boolean}
	     * @example tween.isStarted()
	     * @memberof vf.gui.Tween
	     */
	    get isStarted(): boolean;
	    get delayTime(): number;
	    /**
	     * 获取动画的开始时间
	     */
	    get startTime(): number;
	    /**
	     * 获取动画的开始时间
	     */
	    set startTime(value: number);
	    /**
	     * 设置缓动时长
	     * @param {number} amount 持续的毫秒值
	     * @example tween.duration(2000)
	     * @memberof vf.gui.Tween
	     * @deprecated 不推荐使用这个方法，内部使用
	     * @private
	     */
	    set duration(amount: number | Function);
	    get duration(): number | Function;
	    /**
	     * 逆向缓动
	     * @example tween.reverse()
	     * @param {boolean=} state 是否逆向
	     * @memberof vf.gui.Tween
	     */
	    reverse(state?: boolean, timer?: number): this;
	    /**
	     * 当前动画是否逆转
	     * @return {boolean}
	     * @example tween.reversed() true逆向中
	     * @memberof vf.gui.Tween
	     */
	    reversed(): boolean;
	    /**
	     * 暂停缓动
	     * @example tween.pause()
	     * @memberof vf.gui.Tween
	     */
	    pause(): boolean | this;
	    /**
	     * 播放或恢复播放
	     * @example tween.play()
	     * @memberof vf.gui.Tween
	     */
	    play(): boolean | this;
	    /**
	     * 设置要缓动的目标属性与持续时间
	     * @param {object} properties 目标属性值
	     * @param {number|Object=} [duration=1000] 持续时间
	     * @example let tween = new vf.gui.Tween({x:0}).to({x:100}, 2000)
	     * @memberof vf.gui.Tween
	     */
	    to(properties: any, duration?: number): this;
	    private render;
	    /**
	     * 开始执行缓动
	     * @example tween.start()
	     * @memberof vf.gui.Tween
	     */
	    start(): this;
	    private toEnd;
	    /**
	     * 停止缓动
	     * @example tween.stop()
	     * @memberof vf.gui.Tween
	     */
	    stop(): boolean | this;
	    /**
	     * 设置延迟执行时间
	     * @param {number} amount 延迟等待的时间，毫秒
	     * @example tween.delay(500)
	     * @memberof vf.gui.Tween
	     */
	    delay(amount: number): this;
	    /**
	     * 设置重复执行的次数
	     * @param {number} amount 重复次数
	     * @example tween.repeat(5)
	     * @memberof vf.gui.Tween
	     */
	    repeat(amount: number): this;
	    /**
	     * 设置每个重复执行过程的延迟时间，毫秒
	     * @param {number} amount 延迟值
	     * @example tween.reverseDelay(500)
	     * @memberof vf.gui.Tween
	     */
	    reverseDelay(amount: number): this;
	    /**
	     * 是否在重复执行中启用反向动画
	     * @param {boolean} state true启动
	     * @param {Function=} _easingReverse 反向时的Easing function
	     * @example tween.yoyo(true)
	     * @memberof vf.gui.Tween
	     */
	    yoyo(state?: boolean | Function, _easingReverse?: (k: number) => number): this;
	    /**
	     * 设置缓动函数
	     * @param {Function} _easingFunction 缓动函数的公式，如果设置yoyo的第二个值会应用于逆向缓动
	     * @example tween.easing(Easing.Elastic.InOut)
	     * @memberof vf.gui.Tween
	     */
	    easing(_easingFunction: ((k: number) => number) | any): this;
	    easingReverse(_easingReverse: ((k: number) => number) | any): this;
	    /**
	     * 设置差值
	     * @param {Function} _interpolationFunction 差值的函数
	     * @example tween.interpolation(Interpolation.Bezier)
	     * @memberof vf.gui.Tween
	     */
	    interpolation(_interpolationFunction: (v: any, k: number, value: any) => any): this;
	    /**
	     * 更新动画到指定时间点，进行播放
	     * @param time
	     */
	    gotoAndPlay(time: number): void;
	    /**
	     * 更新动画到指定时间点，停止播放
	     * @param time
	     */
	    gotoAndStop(time: number): void;
	    /**
	     * 更新动画到指定时间点，停止播放
	     * @param time
	     */
	    gotoAndEnd(): void;
	    /**
	     * 更新函数，通过给定的 `time` 设置目标属性变化
	    * @param {number=} deltaTime 帧间隔
	    * @param {Boolean=} preserve 完成后，防止删除动画对象
	     * @param {boolean=} forceTime 强制进行更新渲染，不关心时间是否匹配
	     * @example tween.update(100)
	     * @memberof vf.gui.Tween
	     */
	    update(deltaTime: number, preserve?: boolean, forceTime?: boolean): boolean;
	    release(): void;
	}

}
declare module 'src/core/Ticker' {
	 class Ticker extends vf.Ticker {
	    constructor();
	    start(): void;
	    currentTickerTime: number;
	    update(currentTime: number): void;
	    /**
	     * 时间穿越， 单位ms
	     * @param duration
	     */
	    timeTravel(duration: number): void;
	}
	export const TickerShared: Ticker;
	export {};

}
declare module 'src/tween/Timeline' {
	/**
	 * 基于帧的时间轴控制类
	    *
	 * @example let timeline = new vf.gui.Timeline();
	 *
	 */
	///   types="@vf.js/vf" />
	import { Tween } from 'src/tween/Tween';
	export class TimeLineDefaultData {
	    delay?: number;
	    paused?: boolean;
	    repeat?: number;
	    ease?: ((k: number) => number) | any;
	    yoyo?: boolean;
	    onStart?: Function;
	    onStartParams?: any;
	    onUpdate?: Function;
	    onUpdateParams?: any;
	    onRepeat?: Function;
	    onRepeatParams?: any;
	    onComplete?: Function;
	    onCompleteParams?: any;
	    onReverseComplete?: Function;
	    onReverseCompleteParams?: any;
	}
	export class TimeLineDataItem {
	    tween?: Tween;
	    positionTime: number;
	    hasPlay: boolean;
	}
	export class TimeLine extends vf.utils.EventEmitter {
	    private _defaultParam;
	    private _duration;
	    private _reactDuration;
	    private _objList;
	    private _propertyList;
	    private _tweens;
	    private _pauseTime;
	    private _pauseCallBack?;
	    private _pauseCallBackParam?;
	    private _currenTimer;
	    private _totalRepeat;
	    private _repeat;
	    private _playStates;
	    private _oldPlayStates;
	    private _tickIns;
	    private _isFinite;
	    private _needDownGrade;
	    constructor(options: TimeLineDefaultData);
	    set needDownGrade(value: boolean);
	    get needDownGrade(): boolean;
	    set onStart(value: any);
	    set onStartParams(value: any);
	    set onUpdate(value: any);
	    set onUpdateParams(value: any);
	    set onRepeat(value: any);
	    set onRepeatParams(value: any);
	    set onComplete(value: any);
	    set onCompleteParams(value: any);
	    set onReverseComplete(value: any);
	    set onReverseCompleteParams(value: any);
	    getDefaultParam(): any;
	    private set playStates(value);
	    get duration(): number;
	    get currenTimer(): number;
	    get reversed(): boolean;
	    get paused(): boolean;
	    /**
	     * 顺序播放
	     *
	     */
	    add(value: Tween, position?: number): this;
	    private cacheStartData;
	    private cacheStartDataTest;
	    private getNextValue;
	    private getPropertyList;
	    private toStartData;
	    /**
	     *
	     * 获取时刻数据
	     */
	    setTimeProries(timer: number): void;
	    /**
	     *
	     */
	    addPause(position?: number, callback?: Function, paranms?: any): this;
	    /**
	     * 相当于 add(TweenLite.to(...))
	     */
	    to(element: any, duration: number, options: any, position?: number): this;
	    /**
	     *
	     */
	    play(timer?: number): void;
	    /**
	     * 暂停
	     */
	    pause(): void;
	    /**
	     *
	     */
	    resume(): void;
	    /**
	     * 跳转
	     */
	    seek(timer: number): void;
	    /**
	     * 倒放
	     */
	    reverse(timer?: number): void;
	    /**
	     * 刷新
	     */
	    onUpdata(time: number): void;
	    private playUpdate;
	    private checkPause;
	    private tweenItemPlay;
	    private checkNextRepeat;
	    private checkTweensComplete;
	    private toNext;
	    private complete;
	    private stopAll;
	    release(): void;
	}

}
declare module 'src/tween/private/core' {
	import { Tween } from 'src/tween/Tween';
	import { TimeLine } from 'src/tween/Timeline';
	/**
	 * 插件存储器
	 * @memberof vf.gui.tween
	 * @example
	 * let num = Plugins.num = function (node, start, end) {
	  * return t => start + (end - start) * t
	  * }
	  *
	  * @static
	  */
	export const Plugins: any;
	/**
	 * 添加对象到缓动列表
	 * @param {Tween} tween Tween 实例
	 * @memberof vf.gui.tween
	 * @example
	 * let tween = new vf.gui.tween.Tween({x:0})
	 * tween.to({x:200}, 1000)
	 * vf.gui.tween.add(tween)
	 */
	export function add(tween: Tween): void;
	/**
	 * 没有缓动后，设置运行多少帧后，停止
	 * @param {number} frameCount=120 删除所有动画后，要运行的剩余帧
	 * @memberof vf.gui.tween
	 * @example
	 * vf.gui.tween.FrameThrottle(60)
	 */
	export function FrameThrottle(frameCount?: number): void;
	/**
	 * 延时处理，针对插件、canvas、dom
	 * @param {number} state=true 是否平滑处理
	 * @memberof vf.gui.tween
	 * @example
	 * vf.gui.tween.ToggleLagSmoothing(false)
	 */
	export function ToggleLagSmoothing(_state?: boolean): void;
	/**
	 * 获得所有缓动对象
	 * @memberof vf.gui.tween
	 * vf.gui.tween.getAll()
	 */
	export function getAll(): Tween[];
	/**
	 * 移除所有动画对象
	 * @example  vf.gui.tween.removeAll()
	 * @memberof vf.gui.tween
	 */
	export function removeAll(): void;
	/**
	 * 获取对象
	 * @param {Tween} tween 缓动对象实例
	 * @return {Tween} 返回对象或null
	 * @memberof vf.gui.tween
	 * @example
	 * vf.gui.tween.get(tween)
	 */
	export function get(tween: Tween): Tween | null;
	/**
	 * 从缓动列表移除对象
	 * @param {Tween} tween Tween instance
	 * @memberof vf.gui.tween
	 * @example
	 * vf.gui.tween.remove(tween)
	 */
	export function remove(tween: Tween): void;
	export function removeDisplay(uuid: string): void;
	/**
	 * 按给定时间更新缓动
	 * @param {number=} time 时间戳
	 * @param {Boolean=} preserve 完成后，防止删除动画对象
	 * @memberof vf.gui.tween
	 * @example
	 * vf.gui.tween.update(500)
	 */
	export function update(deltaTime: number): boolean;
	/**
	 * 是否正在运行中
	 * @return {Boolean} 只要还有缓动在运行，返回true
	 * @memberof vf.gui.tween
	 * @example vf.gui.tween.isRunning()
	 */
	export function isRunning(): boolean;
	/**
	 * 返回是否开启延迟平滑状态
	 * @return {Boolean}
	 * @memberof vf.gui.tween
	 * @example vf.gui.tween.isRunning()
	 */
	export function isLagSmoothing(): boolean;
	/**
	 * 添加到列表
	 */
	export function addTimeLine(timeLine: TimeLine): void;
	/**
	 * 移除列表
	 */
	export function removeTimeLine(timeLine: TimeLine): void;
	/**
	 * 销毁所有
	 */
	export function releaseAllTimeLine(): void;

}
declare module 'src/tween/private/index' {
	import { add, get, getAll, isRunning, FrameThrottle, ToggleLagSmoothing, Plugins, remove, removeAll, removeDisplay, update, addTimeLine, removeTimeLine, releaseAllTimeLine } from 'src/tween/private/core';
	import { Interpolation } from 'src/tween/private/Interpolation';
	import * as utils from 'src/tween/private/constants';
	import { TweenEvent } from 'src/event/TweenEvent';
	import { TimeLine } from 'src/tween/TimeLine';
	export { Plugins, get, getAll, removeAll, remove, removeDisplay, add, update, releaseAllTimeLine, addTimeLine, removeTimeLine, isRunning, FrameThrottle, ToggleLagSmoothing, Interpolation, TweenEvent, TimeLine, utils };

}
declare module 'src/core/DisplayLayoutKeys' {
	/** 标记属性失效 */
	export const invalidatePropertiesFlag: symbol;
	/** 标记大小失效 */
	export const invalidateSizeFlag: symbol;
	/** 标记显示失效 */
	export const invalidateDisplayListFlag: symbol;
	/** 是否参与布局 */
	export const includeInLayout: symbol;
	export const width: symbol;
	export const height: symbol;
	export const explicitWidth: symbol;
	export const explicitHeight: symbol;
	export const minWidth: symbol;
	export const maxWidth: symbol;
	export const minHeight: symbol;
	export const maxHeight: symbol;
	export const percentWidth: symbol;
	export const percentHeight: symbol;
	export const measuredWidth: symbol;
	export const measuredHeight: symbol;
	export const oldPreferWidth: symbol;
	export const oldPreferHeight: symbol;
	export const left: symbol;
	export const right: symbol;
	export const top: symbol;
	export const bottom: symbol;
	export const horizontalCenter: symbol;
	export const verticalCenter: symbol;

}
declare module 'src/core/DisplayLayoutValidator' {
	///   types="@vf.js/vf" />
	import { DisplayLayoutAbstract } from 'src/core/DisplayLayoutAbstract'; class UIValidator extends vf.utils.EventEmitter {
	    /**
	     * @private
	     * 创建一个Validator对象
	     */
	    constructor();
	    /**
	     * @private
	     */
	    private targetLevel;
	    /**
	     * @private
	     */
	    private invalidatePropertiesFlag;
	    /**
	     * @private
	     */
	    private invalidateClientPropertiesFlag;
	    /**
	     * @private
	     */
	    private invalidatePropertiesQueue;
	    /**
	     * @private
	     * 标记组件属性失效
	     */
	    invalidateProperties(target: DisplayLayoutAbstract): void;
	    /**
	     * @private
	     * 验证失效的属性
	     */
	    private validateProperties;
	    /**
	     * @private
	     */
	    private invalidateSizeFlag;
	    /**
	     * @private
	     */
	    private invalidateClientSizeFlag;
	    /**
	     * @private
	     */
	    private invalidateSizeQueue;
	    /**
	     * @private
	     * 标记需要重新测量尺寸
	     */
	    invalidateSize(target: DisplayLayoutAbstract): void;
	    /**
	     * @private
	     * 测量尺寸
	     */
	    private validateSize;
	    /**
	     * @private
	     */
	    private invalidateDisplayListFlag;
	    /**
	     * @private
	     */
	    private invalidateDisplayListQueue;
	    /**
	     * @private
	     * 标记需要重新布局
	     */
	    invalidateDisplayList(client: DisplayLayoutAbstract): void;
	    /**
	     * @private
	     * 重新布局
	     */
	    private validateDisplayList;
	    /**
	     * @private
	     * 是否已经添加了事件监听
	     */
	    private listenersAttached;
	    /**
	     * @private
	     * 添加事件监听
	     */
	    private attachListeners;
	    /**
	     * @private
	     * 执行属性应用
	     */
	    private doPhasedInstantiationCallBack;
	    /**
	     * @private
	     */
	    private doPhasedInstantiation;
	    /**
	     * @private
	     * 使大于等于指定组件层级的元素立即应用属性
	     * @param target 要立即应用属性的组件
	     */
	    validateClient(target: DisplayLayoutAbstract): void;
	    removeDepthQueueAll(): void;
	} const validatorShared: UIValidator;
	export default validatorShared;

}
declare module 'src/core/ContainerBase' {
	///   types="@vf.js/vf" />
	/** 容器扩展类，后续便于做延时渲染 */
	export class ContainerBase extends vf.Container {
	    constructor();
	    isEmitRender: boolean;
	    render(renderer: vf.Renderer): void;
	}

}
declare module 'src/core/plugs/LineGradient' {
	///   types="@vf.js/vf" />
	interface TextureFillParamType {
	    canvas?: HTMLCanvasElement;
	    context?: CanvasRenderingContext2D;
	    texture?: vf.Texture;
	    width: number;
	    height: number;
	    anchorX: number;
	    anchorY: number;
	    style: {
	        fillColor: number[] | number[][];
	        fillGradientStops: number[];
	        fillGradientType: 0 | 1;
	    };
	}
	/**
	 * 设置渐变
	 * @param type
	 * @param stops
	 * @param color
	 * @returns
	 */
	export function updateTextureFill(_display: vf.Graphics, fillParam: TextureFillParamType): TextureFillParamType | undefined;
	export {};

}
declare module 'src/core/Background' {
	export class Background {
	    constructor(parent: any);
	    private canvas?;
	    private context?;
	    private texture?;
	    private parent;
	    private _container?;
	    private _oldSrc;
	    private _oldRepeat;
	    private _rect?;
	    private _image?;
	    private _mask?;
	    private _invalidateFlag;
	    isInit: boolean;
	    private _type;
	    get type(): 0 | 1 | 2;
	    set type(value: 0 | 1 | 2);
	    private _color;
	    get color(): number | undefined;
	    set color(value: number | undefined);
	    private _alpha;
	    get alpha(): number;
	    set alpha(value: number);
	    private _radius;
	    get radius(): number;
	    set radius(value: number);
	    private _src;
	    get src(): string | undefined;
	    set src(value: string | undefined);
	    private _positionX;
	    get positionX(): number;
	    set positionX(value: number);
	    private _positionY;
	    get positionY(): number;
	    set positionY(value: number);
	    private _size;
	    get size(): number[] | undefined;
	    set size(value: number[] | undefined);
	    private _repeat;
	    get repeat(): "no-repeat" | "repeat";
	    set repeat(value: "no-repeat" | "repeat");
	    private _fillAlpha;
	    get fillColor(): number | undefined;
	    set fillColor(value: number | undefined);
	    private _fillGradientStops;
	    get fillGradientStops(): number[];
	    set fillGradientStops(value: number[]);
	    private _fillGradientType;
	    get fillGradientType(): 0 | 1;
	    set fillGradientType(value: 0 | 1);
	    private lastW?;
	    private lastH?;
	    update(w: number, h: number): void;
	    private drawRect;
	    private removeImage;
	    release(): void;
	}

}
declare module 'src/core/MaskSprite' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	export interface MaskSprite extends DisplayObject {
	    maskSprite(): vf.Sprite | vf.Graphics;
	}

}
declare module 'src/core/Mask' {
	///   types="@vf.js/vf" />
	import { MaskSprite } from 'src/core/MaskSprite';
	export class Mask {
	    constructor(parent: any);
	    private parent;
	    private _image?;
	    private _oldImage;
	    private _mask;
	    private _invalidateFlag;
	    private _position?;
	    get position(): number[] | undefined;
	    set position(value: number[] | undefined);
	    private _size;
	    get size(): number[] | undefined;
	    set size(value: number[] | undefined);
	    get image(): string | vf.Graphics | MaskSprite | undefined;
	    set image(value: string | vf.Graphics | MaskSprite | undefined);
	    update(w: number, h: number): void;
	    private getGuiObject;
	    release(): void;
	}

}
declare module 'src/core/DisplayObjectAbstract' {
	///   types="@vf.js/vf" />
	import { ContainerBase } from 'src/core/ContainerBase';
	import { Stage } from 'src/core/Stage';
	import { DisplayObject } from 'src/core/DisplayObject';
	import { Background } from 'src/core/Background';
	import { Mask } from 'src/core/Mask';
	export class DisplayObjectAbstract extends vf.utils.EventEmitter implements LifecycleHook, Lifecycle {
	    constructor();
	    /**
	     * 全局唯一ID
	     */
	    readonly uuid: number;
	    id: string;
	    /**
	     * 自定义组价名
	     */
	    name: string;
	    /**
	     * @private
	     * 这个对象在显示列表中的嵌套深度，舞台为1，它的子项为2，子项的子项为3，以此类推。当对象不在显示列表中时此属性值为0.
	     */
	    $nestLevel: number;
	    /**
	     * 是否初始化
	     * @default
	     */
	    initialized: boolean;
	    /**
	     * 舞台引用
	     */
	    $stage?: Stage;
	    /**
	     * 父容器
	     */
	    parent: DisplayObject | Stage | undefined;
	    /**
	     * 节点列表
	     */
	    uiChildren: DisplayObjectAbstract[];
	    /** 没有功能实现，内部编辑器 */
	    container: ContainerBase;
	    /**
	     * 背景(内部使用)
	     */
	    $background: Background;
	    /**
	     * 遮罩(内部使用)，设置遮罩后，组件内部的索引位置可能产生变化
	     */
	    $mask: Mask;
	    /**
	     * 是否开启事件同步
	     */
	    syncabled: boolean;
	    /**
	     * 是否开启恢复时派发事件
	     */
	    resumeabled: boolean;
	    /** 添加显示对象，需集成Core */
	    addChild<T extends DisplayObjectAbstract>(item: T): T;
	    /**
	     * 插入显示对象到特定位置
	     * @param item 显示对象
	     * @param index 要插入的索引，最大值为当前显示列表的长度，最小值为0
	     */
	    addChildAt<T extends DisplayObjectAbstract>(item: T, index: number): T;
	    getChildAt(index: number): DisplayObjectAbstract;
	    getChildByUUID(uuid: number): DisplayObjectAbstract | undefined;
	    _getChildById(id: string): DisplayObjectAbstract | undefined;
	    getChildByPath(ids: string[]): DisplayObjectAbstract | undefined;
	    /**
	     * 移除已添加的UI组件
	     * @param UIObject 要移除的UI组件
	     */
	    removeChild<T extends DisplayObjectAbstract>(item: T): T;
	    removeChildAt<T>(index: number): T;
	    /**
	     * 移除元素
	     * @param release 是否释放子节点，破坏结构
	     * @param beginIndex 开始
	     * @param endIndex 结束
	     */
	    removeChildren(release?: boolean, beginIndex?: number | undefined, endIndex?: number | undefined): void;
	    /**
	     * 是否绘制显示对象，如果false不进行绘制，不过仍然会进行相关的更新计算。
	     * 只影响父级的递归调用。
	     */
	    set renderable(value: boolean);
	    get renderable(): boolean;
	    private _interactive;
	    /**
	     * 对象是否可以接收事件
	     */
	    set interactive(value: boolean);
	    get interactive(): boolean;
	    private _interactiveChildren;
	    /**
	     * 子对象是否可以接收事件，设置false后，会绕过HitTest方法的递归
	     */
	    set interactiveChildren(value: boolean);
	    get interactiveChildren(): boolean;
	    /**
	     * 子类实现
	     */
	    validateNow(): void;
	    private _enabled;
	    get enabled(): boolean;
	    set enabled(value: boolean);
	    /**
	     * 是否可见
	     */
	    private _visible;
	    get visible(): boolean;
	    set visible(value: boolean);
	    /** 清除全部事件 */
	    offAll(event?: string | symbol): this;
	    get stage(): Stage | undefined;
	    protected checkInvalidateFlag(): void;
	    load(): void;
	    release(): void;
	    $onInit(): void;
	    $onLoad(): void;
	    $onRelease(): void;
	    $onAddStage(): void;
	    $onRemoveStage(): void;
	}

}
declare module 'src/core/DisplayLayoutAbstract' {
	///   types="@vf.js/vf" />
	import { DisplayObjectAbstract } from 'src/core/DisplayObjectAbstract';
	export const $tempLocalBounds: vf.Rectangle;
	/**
	 * UI 布局的基础属性类
	 */
	export class DisplayLayoutAbstract extends DisplayObjectAbstract {
	    constructor();
	    isContainer: boolean;
	    /**
	     * @private
	     */
	    $values: any;
	    /**
	     * @private
	     * 定义的所有变量请不要添加任何初始值，必须统一在此处初始化。
	     */
	    protected initializeUIValues(): void;
	    /**
	     * @private
	     * 检查属性失效标记并应用
	     */
	    protected checkInvalidateFlag(): void;
	    /**
	     * @private
	     * 验证组件的属性
	     */
	    validateProperties(): void;
	    /**
	     * @private
	     * 验证组件的尺寸
	     */
	    validateSize(recursive?: boolean): void;
	    /**
	     * @private
	     * 验证子项的位置和大小，并绘制其他可视内容
	     */
	    validateDisplayList(): void;
	    /**
	     * @private
	     * 提交属性，子类在调用完invalidateProperties()方法后，应覆盖此方法以应用属性
	     */
	    protected commitProperties(): void;
	    /**
	     * 测量显示对象宽高，如果子类没有重写，默认是this.container.width..
	     */
	    protected measure(): void;
	    /**
	     * @private
	     * 测量组件尺寸，返回尺寸是否发生变化
	     */
	    protected measureSizes(): boolean;
	    /**
	     * @private
	     *
	     * @returns
	     */
	    protected getPreferredUWidth(): number;
	    /**
	     * @private
	     */
	    protected getPreferredUHeight(): number;
	    /**
	     * @private
	     * 获取组件的首选尺寸,常用于父级的measure()方法中
	     * 按照：外部显式设置尺寸>测量尺寸 的优先级顺序返回尺寸，
	     */
	    getPreferredBounds(bounds: vf.Rectangle): vf.Rectangle;
	    /**
	    * @private
	    * 标记提交过需要延迟应用的属性，以便在稍后屏幕更新期间调用该组件的 commitProperties() 方法。
	    *
	    * 例如，要更改文本颜色和大小，如果在更改颜色后立即进行更新，然后在设置大小后再更新大小，就有些浪费。
	    * 同时更改两个属性后再使用新的大小和颜色一次性呈示文本，效率会更高。<p/>
	    *
	    * 通常，子类应覆盖 commitProperties() 方法，而不是覆盖此方法。
	     */
	    invalidateProperties(): void;
	    /**
	    * @private
	    * 标记提交过需要验证组件尺寸，以便在稍后屏幕更新期间调用该组件的 measure(),updatesize() 方法。
	    */
	    invalidateSize(): void;
	    /**
	    * @private
	    * 标记需要验证显示列表，以便在稍后屏幕更新期间调用该组件的 updateDisplayList() 方法。
	    */
	    invalidateDisplayList(): void;
	    /**
	     * @private
	     * 标记父级容器的尺寸和显示列表为失效
	     */
	    invalidateParentLayout(): void;
	    /**
	     * @private
	     * 设置组件的布局位置
	     */
	    setPosition(x?: number | undefined, y?: number | undefined): void;
	    /**
	     * @private
	     * 设置测量结果。
	     * @param width 测量宽度
	     * @param height 测量高度
	     */
	    setMeasuredSize(width: number, height: number): void;
	    /**
	     * @private
	     * 设置组件的宽高。此方法不同于直接设置width,height属性，
	     * 不会影响显式标记尺寸属性
	     */
	    setActualSize(w: number, h: number, isInvalidate?: boolean): void;
	    updateTransform(): void;
	    /**
	     * 更新背景
	     */
	    protected updateBackground(unscaledWidth: number, unscaledHeight: number): void;
	    /**
	     * 更新遮罩
	     */
	    protected updateMask(unscaledWidth: number, unscaledHeight: number): void;
	    /**
	     * @private
	     * 更新最终的组件宽高
	     */
	    protected updateSize(): void;
	    /**
	     * 更新显示列表,子类重写，实现布局
	     */
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    /**
	     * @private
	     * 立即应用组件及其子项的所有属性
	     */
	    validateNow(): void;
	    /**
	     * @private
	    * 验证并更新此对象的属性和布局，如果需要的话重绘对象。
	    *
	    * 通常只有当脚本执行完毕后，才会处理要求进行大量计算的处理属性。<p/>
	    *
	    * 例如，对 width 属性的设置可能会延迟，因为此设置需要重新计算这些对象的子项或父项的宽度。
	    * 如果脚本多次设置了 width 属性，则延迟处理可防止进行多次处理。此方法允许您手动覆盖此行为。
	     */
	    validateSizeNow(): void;
	    /**
	     * 指定此组件是否包含在父容器的布局中。若为false，则父级容器在测量和布局阶段都忽略此组件。默认值为true。
	     * 注意，visible属性与此属性不同，设置visible为false，父级容器仍会对其布局。
	     */
	    get includeInLayout(): boolean;
	    set includeInLayout(value: boolean);
	    /**
	     * @private
	     * 距父级容器离左边距离
	     */
	    get left(): any;
	    set left(value: any);
	    /**
	     * @private
	     * 距父级容器右边距离
	     */
	    get right(): any;
	    set right(value: any);
	    /**
	     * @private
	     * 距父级容器顶部距离
	     */
	    get top(): any;
	    set top(value: any);
	    /**
	     * @private
	     * 距父级容器底部距离
	     */
	    get bottom(): any;
	    set bottom(value: any);
	    /**
	     * @private
	     * 在父级容器中距水平中心位置的距离
	     */
	    get horizontalCenter(): any;
	    set horizontalCenter(value: any);
	    /**
	     * @private
	     * 在父级容器中距竖直中心位置的距离
	     */
	    get verticalCenter(): any;
	    set verticalCenter(value: any);
	    /**
	     * @private
	     * 相对父级容器宽度的百分比
	     */
	    get percentWidth(): number;
	    set percentWidth(value: number);
	    /**
	     * @private
	     * 相对父级容器高度的百分比
	     */
	    get percentHeight(): number;
	    set percentHeight(value: number);
	    /**
	     * @private
	     * 外部显式指定的宽度
	     */
	    get explicitWidth(): number;
	    /**
	     * @private
	     * 外部显式指定的高度
	     */
	    get explicitHeight(): number;
	    /**
	     * @private
	     * 组件的最小宽度,此属性设置为大于maxWidth的值时无效。同时影响测量和自动布局的尺寸。
	     */
	    get minWidth(): number;
	    set minWidth(value: number);
	    /**
	     * @private
	     * 组件的最大高度。同时影响测量和自动布局的尺寸。
	     */
	    get maxWidth(): number;
	    set maxWidth(value: number);
	    /**
	     * @private
	     * 组件的最小高度,此属性设置为大于maxHeight的值时无效。同时影响测量和自动布局的尺寸。
	     */
	    get minHeight(): number;
	    set minHeight(value: number);
	    /**
	     * @private
	     * 组件的最大高度,同时影响测量和自动布局的尺寸。
	     */
	    get maxHeight(): number;
	    set maxHeight(value: number);
	    allInvalidate(): void;
	    /**
	     * @private
	     * 组件宽度设置为undefined将使用组件的measure()方法自动计算尺寸
	     */
	    get width(): number;
	    /**
	     * @private
	     *
	     * @param value
	     */
	    set width(value: number);
	    /**
	     * @private
	     * 组件高度,默认值为NaN,设置为NaN将使用组件的measure()方法自动计算尺寸
	     */
	    get height(): number;
	    /**
	     * @private
	     *
	     * @param value
	     */
	    set height(value: number);
	    get scaleX(): number;
	    set scaleX(value: number);
	    get scaleY(): number;
	    set scaleY(value: number);
	    get x(): number;
	    set x(value: number);
	    get y(): number;
	    set y(value: number);
	    get skewX(): number;
	    set skewX(value: number);
	    get skewY(): number;
	    set skewY(value: number);
	    get pivotX(): number;
	    set pivotX(value: number);
	    get pivotY(): number;
	    set pivotY(value: number);
	    get rotation(): number;
	    set rotation(value: number);
	    /**
	     *  =不可用= 设置索引层级，每次父级变化时，会排序 （未实现）
	     */
	    get zIndex(): number;
	    set zIndex(value: number);
	}

}
declare module 'src/event/EventType' {
	export const enum EventType {
	    /**
	     * 状态变化 ：IVFData -> VFStateCode
	     */
	    STATUS = "status",
	    /**
	     * 推送消息到外部
	     */
	    MESSAGE = "message",
	    /**
	     * 接收外部消息
	     */
	    ONMESSAGE = "onMessage",
	    /**
	     * 通用状态变化
	     */
	    STATE = "state",
	    /**
	     * 启动/开始
	     */
	    START = "start",
	    /**
	     * 心跳
	     */
	    TICK = "tick",
	    /**
	     * 更新
	     */
	    UPDATE = "update",
	    /**
	     * 已改变
	     */
	    CHANGED = "changed",
	    /**
	     * 结束
	     */
	    END = "end"
	}

}
declare module 'src/event/EventLevel' {
	/**
	 * status: 状态变化
	 *
	 * command: 执行操作
	 *
	 * ----------------------
	 *
	 * Info: 默认的等级
	 *
	 * Warn: 表示可能对系统有损害的情况
	 *
	 * 表示非常严重的错误等级，记录极有可能导致应用程序终止运行的致命错误信息；
	 */
	export const enum EventLevel {
	    /**
	     * 状态
	     */
	    STATUS = "status",
	    /**
	     * 命令
	     */
	    COMMAND = "command",
	    /**
	     * 默认的等级
	     */
	    INFO = "info",
	    /**
	     * 警告
	     */
	    WARNING = "warning",
	    /**
	     * 错误
	     */
	    ERROR = "error",
	    /**
	     * 原生
	     */
	    NATIVE = "native"
	}

}
declare module 'src/core/Scheduler' {
	///   types="@vf.js/vf" />
	/**
	 * Schedule anything
	 *
	 * @author 8088
	 */
	export class Scheduler extends vf.utils.EventEmitter {
	    get id(): number;
	    static schedulerList: Scheduler[];
	    static stopAll(): void;
	    static setEnterFrame(listener: (data?: any) => void): Scheduler;
	    static setInterval(time: number, listener: (data?: any) => void): Scheduler;
	    static setTimeout(time: number, listener: (data?: any) => void): Scheduler;
	    _interval: number;
	    _timeout: number;
	    private _id;
	    private _running;
	    private _pausing;
	    private _totalDuration;
	    private _intervalDuration;
	    constructor(timeout?: number, interval?: number);
	    restart(): void;
	    stop(): void;
	    pause(): void;
	    resume(): void;
	    private run;
	}

}
declare module 'src/core/Stage' {
	///   types="@vf.js/vf" />
	import { DisplayLayoutAbstract } from 'src/core/DisplayLayoutAbstract';
	import { SyncManager } from 'src/interaction/SyncManager';
	/**
	 * UI的舞台对象，展示所有UI组件
	 *
	 * @class
	 * @param width {Number} 舞台宽度
	 * @param height {Number} 舞台高度
	 */
	export class Stage extends DisplayLayoutAbstract {
	    constructor(width: number, height: number, app: vf.Application);
	    app: vf.Application;
	    syncManager: SyncManager | undefined;
	    resumeStatusFlag: boolean;
	    /**
	     * 是否组织原始数据继续传递
	     */
	    originalEventPreventDefault: boolean;
	    get stageWidth(): number;
	    get stageHeight(): number;
	    get scaleX(): number;
	    set scaleX(value: number);
	    get scaleY(): number;
	    set scaleY(value: number);
	    set Scale(value: vf.Point);
	    /**
	     * 是否同步交互事件
	     */
	    private _syncInteractiveFlag;
	    set syncInteractiveFlag(value: boolean);
	    get syncInteractiveFlag(): boolean;
	    getSystemEvent(): vf.utils.EventEmitter;
	    sendToPlayer(e: any): void;
	    release(): void;
	    releaseAll(): void;
	    resize(): void;
	    /**
	     * 接收来自player的消息
	     * @param msg
	     */
	    receiveFromPlayer(msg: any): void;
	    /**
	     * 截图功能
	     */
	    private _virCanvas;
	    private getVitualCanvas;
	    screenShots(x: number, y: number, width: number, height: number, endWidth?: number, endHeight?: number, displayObject?: vf.DisplayObject): vf.Texture;
	}

}
declare module 'src/enum/FollowLineEnum' {
	export const enum Role {
	    /** 老师 */
	    teacher = "T",
	    /** 学生 */
	    student = "S"
	}
	export const enum Operate {
	    add = "1",
	    remove = "2",
	    clear = "3"
	}

}
declare module 'src/interaction/SyncManager' {
	/**
	 * 用于同步输入事件
	 * by ziye
	 */
	///   types="@vf.js/vf" />
	import { InteractionEvent } from 'src/event/InteractionEvent';
	import { Stage } from 'src/core/Stage';
	import { DisplayObjectAbstract } from 'src/core/DisplayObjectAbstract';
	import { Role } from 'src/enum/FollowLineEnum';
	export class SyncManager extends vf.utils.EventEmitter {
	    constructor(stage: Stage);
	    /**
	     * 对应一个stage有一个syncManager的实例
	     */
	    static getInstance(stage?: Stage | undefined): SyncManager | undefined;
	    static getIns(): SyncManager | undefined;
	    static instance?: SyncManager;
	    private _role;
	    mode: number;
	    resumeStatusFlag: boolean;
	    resumeImmediately: boolean;
	    offsetTime: number;
	    private _initTime;
	    private _interactionEvent;
	    private _stage;
	    private _lostMoveEvent;
	    private _throttleMoveFlag;
	    private _throttleMoveTimer;
	    private _evtDataList;
	    private _readystate;
	    private _sendId;
	    private _lastSId;
	    private _lastTId;
	    private _lastSEventData;
	    private _lastTEventData;
	    private _swaitingEventList;
	    private _twaitingEventList;
	    private _waitTimer;
	    private _resumeTimer;
	    private _heartTimer;
	    private _autoHeartTimer;
	    autoHeartFlag: any;
	    _initDataTimer: number;
	    initDataFlag: boolean;
	    private _resumeStoreList;
	    private _startFlag;
	    private _lostEvent;
	    private _throttleEventTimer;
	    private _lastEventData?;
	    /**
	     * log
	     */
	    private log;
	    /**
	     * 清理syncManager
	     */
	    stop(): void;
	    /**
	     * 开始同步
	     */
	    start(): void;
	    /**
	     * 重置syncManager
	     */
	    private reset;
	    /**
	     * 角色
	     */
	    set role(value: Role);
	    get role(): Role;
	    /**
	     * 自动心跳，自动心跳基于每次输入操作之后，心跳10次，间隔0.5
	     * @param duration
	     * @param role
	     */
	    private autoHeartEvent;
	    /**
	     * 同步心跳
	     * @duration 心跳间隔
	     * @role 1-老师  2-学生   12-老师学生均发心跳
	     */
	    syncHeartEvent(duration: number, role?: number): void;
	    /**
	     * 发送心跳
	     */
	    sendHeartEvent(): void;
	    /**
	     * 收集交互事件
	     */
	    collectEvent(e: InteractionEvent, obj: DisplayObjectAbstract): void;
	    /**
	     * 发送自定义事件
	     * customData 自定义数据
	     */
	    sendCustomEvent(customData: any): void;
	    /**
	     * 发送当前时间
	     */
	    private sendSyncTimeEvent;
	    /**
	     * 接收操作
	     * @signalType 信令类型  live-实时信令   history-历史信令
	     */
	    receiveEvent(eventData: any, signalType?: string): void;
	    private dealLiveEvent;
	    /**
	     * 检查eventId是否正确
	     */
	    private checkEventId;
	    /**
	     * 检查是否有暂存的event需要执行
	     * forceFlag: 是否强制执行
	     */
	    private checkWaitingEvent;
	    /**
	     * 获取当前时间
	     */
	    private currentTime;
	    /**
	     * 构造一个新的e，用于同步，数据要尽量精简
	     */
	    private createEventData;
	    /**
	     * 发送操作(稀疏前的每一次单条发送)
	     */
	    private sendEvent;
	    /**
	     * 智能检测，如果是end，把所有暂存的一起立即发送
	     * 如果是start的，暂存起来，启动300ms的定时
	     * 如果是其他的，已经有暂存，则将继续暂存，否则立即发送
	     * @param eventData
	     */
	    private checkEventData;
	    private dealLostEvent;
	    /**
	     * 真实发送(稀疏后的真实发送，可能是单条，可能是数组)
	     */
	    private realSendEvent;
	    /**
	     * 更新节流状态
	     */
	    private throttleUpdate;
	    /**
	     * 节流，每100ms发送一次
	     * @param eventData
	     */
	    private throttle;
	    private resetStage;
	    /**
	     * 解析收到的event
	     */
	    private parseEventData;
	    /**
	     * 时间未到，需要穿越到未来
	     */
	    private timeTravel;
	    /**
	     * 模板初始化
	     * @param history
	     */
	    private initData;
	    /**
	     * 处理历史信令，将历史输入事件按时间顺序放置到一个数组
	     * @param eventData
	     */
	    private dealHistoryEvent;
	    private resumeStatusImmediately;
	    /**
	     * 恢复状态
	     */
	    private resumeStatus;
	    private resetCallback;
	}

}
declare module 'src/interaction/ClickEvent' {
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 * 点击触摸相关的事件处理订阅类,UI组件内部可以创建此类实现点击相关操作
	 *
	 *  可侦听事件:
	 * ```
	 *  {InteractionEvent}.TouchEvent.onHover
	 *  {InteractionEvent}.TouchEvent.onPress
	 *  {InteractionEvent}.TouchEvent.onClick
	 *  {InteractionEvent}.TouchEvent.onMove
	 * ```
	 *
	 * @example 可查看 `TestSliceSprite` 示例
	 *
	 * @since 1.0.0
	 */
	export class ClickEvent {
	    /**
	     * ClickEvent 构造函数
	     * @param obj 调用的显示对象
	     * @param includeHover 是否监听鼠标移上与移出，默认true
	     * @param rightMouseButton 是否开启鼠标右键点击，默认false
	     * @param doubleClick 是否开启鼠标双击,默认false
	     */
	    constructor(obj: DisplayObject, includeHover?: boolean, rightMouseButton?: boolean, doubleClick?: boolean);
	    /** 当前按下状态的所有对象，为了弹起统一做处理 */
	    private static downObjects;
	    private obj;
	    id: number;
	    /** 是否开启本地坐标转换，开启后，事件InteractionEvent中的localX localY为本地坐标，false情况下为0 */
	    isOpenLocalPoint: boolean;
	    private localOffset;
	    private offset;
	    private movementX;
	    private movementY;
	    private ishover;
	    private mouse;
	    private bound;
	    private right;
	    private hover;
	    double: boolean;
	    private time;
	    private isStop;
	    private deviceType;
	    getTarget(): DisplayObject;
	    startEvent(): void;
	    private _onStageTouchOutside;
	    private _onMouseRight;
	    /** 清除拖动 */
	    stopEvent(): void;
	    private _onMouseDown;
	    private emitTouchEvent;
	    private _mouseUpAll;
	    private _onMouseUp;
	    private _onMouseUpOutside;
	    private _onMouseOver;
	    private _onMouseOut;
	    private _tempMovePoint;
	    private _onMouseMove;
	    private setLocalPoint;
	    private removeAllMove;
	    remove(): void;
	}

}
declare module 'src/interaction/DragDropController' {
	import { DisplayObject } from 'src/core/DisplayObject';
	import { InteractionEvent } from 'src/event/InteractionEvent';
	/**
	 * 记录当前正在拖动的UI组件列表
	 * @private
	 */
	export const _items: DisplayObject[];
	export const _dropTargets: any[];
	/**
	 * 添加拖动组件到控制器
	 * @param item 要添加的UI组件
	 * @param e 传送的事件
	 * @returns true|false
	 * @since 1.0.0
	 */
	export function add(item: DisplayObject, e: InteractionEvent): boolean;
	export function remove(item: DisplayObject): boolean;
	/**
	 * 添加掉落容器
	 * @param group
	 * @param target
	 */
	export function addDropTarget(group: string, target: DisplayObject): void;
	/**
	 * 获取对应的掉落容器
	 * @param group
	 */
	export function getDropTargets(group: string): DisplayObject[];
	export function removeDropTarget(target: DisplayObject): void;
	/**
	 * 获取正在拖动组件
	 * @param item 要获取的UI组件
	 * @returns flase | item
	 */
	export function getItem(item: DisplayObject): false | DisplayObject;
	/**
	 * 根据事件对象与分组名获取拖动项
	 * @param e 事件对象
	 * @param group 分组名
	 */
	export function getEventItem(e: InteractionEvent, group: string | undefined): false | DisplayObject | null;

}
declare module 'src/interaction/DragEvent' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { InteractionEvent } from 'src/event/InteractionEvent';
	/**
	 * 多拽相关的事件处理类
	 *
	 *  可侦听事件:
	 * ```
	 *  {InteractionEvent}.DraggableEvent.onDragPress
	 *  {InteractionEvent}.DraggableEvent.onDragStart
	 *  {InteractionEvent}.DraggableEvent.onDragMove
	 *  {InteractionEvent}.DraggableEvent.onDragEnd
	 * ```
	 *  可赋值方法:
	 * ```
	 * onPress: ((e: InteractionEvent, isPressed: boolean,dragObj?: DragEvent) => void) | undefined;
	 * onDragEnd: ((e: InteractionEvent,dragObj?: DragEvent) => void) | undefined
	 * onDragMove: ((e: InteractionEvent, offset: vf.Point,dragObj?: DragEvent) => void) | undefined
	 * onDragStart: ((e: InteractionEvent,dragObj?: DragEvent) => void) | undefined
	 * ```
	 *
	 * @example 可查看 `Slider` 源码
	 *
	 * @since 1.0.0
	 */
	export class DragEvent {
	    constructor(obj: DisplayObject);
	    private obj;
	    id: number;
	    private offset;
	    private movementX;
	    private movementY;
	    private bound;
	    start: vf.Point;
	    private mouse;
	    private cancel;
	    private dragging;
	    private isStop;
	    private ishover;
	    /**
	     * 限制拖动抽,XY,X抽或Y抽
	     */
	    dragRestrictAxis?: "x" | "y";
	    startEvent(): void;
	    executeAction(e: InteractionEvent): void;
	    private _onDragOver;
	    private _onMouseOut;
	    private _onDragStart;
	    private _onDragMove;
	    private _onDragEnd;
	    /** 清除拖动 */
	    stopEvent(): void;
	    remove(): void;
	    onDragPress: ((e: InteractionEvent, isPressed: boolean, dragObj?: DragEvent) => void) | undefined;
	    onDragEnd: ((e: InteractionEvent, dragObj?: DragEvent) => void) | undefined;
	    onDragMove: ((e: InteractionEvent, offset: vf.Point, dragObj?: DragEvent) => void) | undefined;
	    onDragStart: ((e: InteractionEvent, dragObj?: DragEvent) => void) | undefined;
	    onDragHover: ((e: InteractionEvent, isHover: boolean, dragObj?: DragEvent) => void) | undefined;
	}

}
declare module 'src/display/Label' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 * 文本
	 *
	 * 中文换行特殊处理 xxxx.style.breakWords = true;
	 *
	 * 当文本容器设置宽高后，文字默认会根据文本容器宽高居中.
	 *
	 * 当文本容器设置宽高后，可通过 style.textAlign 进行文字位置调整
	 *
	 * @example let label = new vf.gui.Label();
	 *
	 */
	export class Label extends DisplayObject {
	    readonly sprite: vf.Text;
	    private _lineGraphics;
	    private _textDecorationWidth;
	    private _textDecorationStyle;
	    private _textAlpha;
	    private readonly _defaultColor;
	    private _color?;
	    constructor(text?: string);
	    private get widthNoShadow();
	    private get heightNoShadow();
	    private onWidthChange;
	    /**
	     * 设置分辨力比例
	     */
	    get resolution(): number;
	    set resolution(value: number);
	    get fillColor(): number[] | number[][];
	    set fillColor(value: number[] | number[][]);
	    set fillAlpha(value: number);
	    /**
	     * 文本颜色
	     */
	    get color(): string | number | number[] | string[] | undefined;
	    set color(value: string | number | number[] | string[] | undefined);
	    /**
	     * 文字透明度
	     */
	    get textAlpha(): number;
	    set textAlpha(value: number);
	    get textDecorationStyle(): 'Solid' | 'Double';
	    set textDecorationStyle(value: 'Solid' | 'Double');
	    /**
	     * 文本内容
	     */
	    get text(): string;
	    set text(value: string);
	    set fontCssStyle(value: any);
	    private setLine;
	    private showUnderLine;
	    private autoDrawLine;
	    private getStartPosX;
	    private getStartPosY;
	    private drawLine;
	    /**
	     * 测量显示对象宽高，如果子类没有重写，默认是this.container.width..
	     */
	    protected measure(): void;
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    private cacheOldData;
	    private clearLineGraphics;
	    release(): void;
	}

}
declare module 'src/utils/GifReader' {
	export class GifReader {
	    private _width;
	    private _height;
	    private _frames;
	    private _loop_count;
	    private _buf;
	    constructor(arrayBuffer: ArrayBuffer);
	    get width(): number;
	    get height(): number;
	    get numFrames(): number;
	    get loopCount(): number;
	    getFrameInfo(frame_num: number): FrameInfo;
	    decodeAndBlitFrameBGRA(frame_num: number, pixels: Uint8ClampedArray): FrameInfo;
	    decodeAndBlitFrameRGBA(frame_num: number, pixels: Uint8ClampedArray): FrameInfo;
	}
	export interface FrameInfo {
	    x: number;
	    y: number;
	    width: number;
	    height: number;
	    has_local_palette: boolean;
	    palette_offset: number;
	    palette_size: number;
	    data_offset: number;
	    data_length: number;
	    transparent_index: number;
	    interlaced: boolean;
	    delay: number;
	    disposal: number;
	}

}
declare module 'src/utils/GifFrames' {
	///   types="@vf.js/vf" />
	import { GifReader } from 'src/utils/GifReader';
	export class GifFrames {
	    private _frames;
	    private _gif;
	    constructor(_resource: vf.LoaderResource | ArrayBuffer);
	    private calcSingleTextureWidth;
	    get gif(): GifReader;
	    get frames(): Array<GifFrame>;
	    private generateTextureFromGifData;
	    get numFrames(): number;
	    getFrame(index: number): GifFrame;
	}
	export class GifFrame {
	    index: number;
	    texture: vf.Texture;
	    delayTime: number;
	    constructor(index: number, texture: vf.Texture, delayTime: number);
	}

}
declare module 'src/utils/GifSequence' {
	import { GifSprite } from 'src/display/private/GifSprite';
	import { GifFrame } from 'src/utils/GifFrames';
	export class GifSequence {
	    sprite: GifSprite;
	    name: string;
	    frames: Array<GifFrame>;
	    loopCount: number;
	    private _playing;
	    private _nextFrameTime;
	    private _loopedCount;
	    private _speedScale;
	    private _timeDistance;
	    constructor(sprite: GifSprite, name: string, frames: Array<GifFrame>, loopCount: number);
	    setEndlessLoop(): void;
	    get speedScale(): number;
	    set speedScale(value: number);
	    get duration(): number;
	    get playing(): boolean;
	    stop(skipEmit?: boolean): void;
	    play(): boolean;
	    private get currentFrameIndex();
	    get loopedCount(): number;
	    private update;
	}

}
declare module 'src/display/private/GifSprite' {
	///   types="@vf.js/vf" />
	import { GifFrame, GifFrames } from 'src/utils/GifFrames';
	import { GifSequence } from 'src/utils/GifSequence';
	export class GifSprite extends vf.Sprite {
	    static EVENT: {
	        FRAME_CHANGED: string;
	        PLAY: string;
	        STOP: string;
	        COMPLETE: string;
	        END: string;
	    };
	    private _frames;
	    private _sequences;
	    private _currentSequence;
	    private _currentFrame;
	    constructor(resource: vf.LoaderResource | string | GifFrames);
	    get gifFrames(): GifFrames;
	    get totalFrames(): number;
	    getSequence(name?: string): GifSequence;
	    addSequence(name: string, frames: Array<number>, loopCount?: number): GifSequence;
	    private _addSequence;
	    setSequence(name: string, play?: boolean): void;
	    destroy(): void;
	    play(): void;
	    stop(): void;
	    setFrame(frame: number): void;
	    setGifFrame(frame: GifFrame): void;
	    gotoAndStop(frame: number): void;
	    gotoAndPlay(frame: number): void;
	    get currentFrame(): number;
	    get currentGifFrame(): GifFrame;
	    get currentSequence(): GifSequence;
	    get playing(): boolean;
	    get speedScale(): number;
	    set speedScale(value: number);
	}

}
declare module 'src/display/Image' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { MaskSprite } from 'src/core/MaskSprite';
	import { GifSprite } from 'src/display/private/GifSprite';
	/**
	 * 图片
	 *
	 * @example let image = new vf.gui.Image();
	 *
	 */
	export class Image extends DisplayObject implements MaskSprite {
	    constructor();
	    /** 可以支持遮罩的组件 */
	    maskSprite(): vf.Sprite;
	    protected _sprite: vf.Sprite | vf.TilingSprite | vf.NineSlicePlane | GifSprite | undefined;
	    protected _texture: vf.Texture | undefined;
	    protected _source: number | string | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | undefined;
	    /**
	     * 图像路径或位图对象
	     */
	    private _src;
	    private _oldSrc?;
	    get src(): number | string | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | undefined;
	    set src(value: number | string | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | undefined);
	    private _isGif;
	    private _scale9Grid?;
	    private _oldScale9Grid?;
	    /**
	     * 矩形区域，它定义素材对象的九个缩放区域。
	     *
	     * fillMode = scale 时，[leftWidth,rightWidth,topHeight,bottomHeight]
	     *
	     * fillMode = repeat 是，[scalex,scaley,x,y]
	     */
	    get scale9Grid(): any[] | number[] | undefined;
	    set scale9Grid(value: any[] | number[] | undefined);
	    private _fillMode?;
	    private _oldFillMode?;
	    /**
	     * 填充模式
	     * 设置scale后，可设置scale9Grid进行调整缩放区域
	     */
	    get fillMode(): "repeat" | "no-repeat" | "scale" | undefined;
	    set fillMode(value: "repeat" | "no-repeat" | "scale" | undefined);
	    /**
	     * 锚点，调整位图的坐标中点 0-1
	     */
	    get anchorX(): number;
	    set anchorX(value: number);
	    /**
	     * 锚点，调整位图的坐标中点 0-1
	     */
	    get anchorY(): number;
	    set anchorY(value: number);
	    setSpeiteSize(unscaledWidth?: number, unscaledHeight?: number): void;
	    protected measure(): void;
	    protected srcSystem(): void;
	    protected commitProperties(): void;
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    release(): void;
	}

}
declare module 'src/display/private/InputBase' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { ClickEvent, InteractionEvent } from 'src/interaction/Index';
	/**
	 * 输入对象的基础类
	 */
	export class InputBase extends DisplayObject {
	    constructor();
	    /** 是否开启鼠标或触摸点击，开启后，接收TouchMouseEvent */
	    get interactabled(): boolean;
	    set interactabled(value: boolean);
	    protected clickEvent: ClickEvent;
	    private _currentState;
	    protected get currentState(): "up" | "move" | "down" | "disabled";
	    protected set currentState(value: "up" | "move" | "down" | "disabled");
	    protected _tabIndex: undefined | number;
	    protected _tabGroup: undefined | string;
	    protected _focused: boolean;
	    protected _useTab: boolean;
	    protected _usePrev: boolean;
	    protected _useNext: boolean;
	    protected _down: boolean;
	    private _clickSound?;
	    get clickSound(): string | undefined;
	    set clickSound(value: string | undefined);
	    set double(value: boolean);
	    get double(): boolean;
	    private _useMoveEvent;
	    set useMoveEvent(value: boolean);
	    get useMoveEvent(): boolean;
	    /**
	     * 状态皮肤，
	     */
	    up?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    /**
	     * 状态皮肤，
	     */
	    down?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    /**
	     * 状态皮肤，
	     */
	    move?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    /**
	     * 状态皮肤，
	     */
	    disabled?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    /**
	     * 选中状态皮肤，
	     */
	    upAndSelected?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    /**
	     * 选中状态皮肤，
	     */
	    downAndSelected?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    /**
	     * 选中状态皮肤，
	     */
	    moveAndSelected?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    /**
	     * 选中状态皮肤，
	     */
	    disabledAndSelected?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    protected onMove(): void;
	    protected onHover(): void;
	    protected onPress(e: InteractionEvent, thisObj: DisplayObject, isPress: boolean): void;
	    protected onClick(e: InteractionEvent): void;
	    protected keyDownEvent(event: WheelEvent | Event): void;
	    protected documentMouseDown(): void;
	    private keyDownEventBind;
	    protected _bindEvents(): void;
	    protected _clearEvents(): void;
	    focus(): void;
	    blur(): void;
	    release(): void;
	    setTabIndex(index: number | undefined, group: string | undefined): void;
	}

}
declare module 'src/display/Button' {
	import { Label } from 'src/display/Label';
	import { Image } from 'src/display/Image';
	import { InputBase } from 'src/display/private/InputBase';
	/**
	 * 按钮
	 *
	 * @example let button = new vf.gui.Button();
	 *
	 *
	 */
	export class Button extends InputBase {
	    constructor();
	    protected _selectedStr: "AndSelected" | "";
	    protected _oldState: string;
	    private _offsetY;
	    /** 状态展示 */
	    readonly img: Image;
	    /** 文字展示 */
	    readonly label: Label;
	    private _text;
	    /**
	     * 设置按钮的文本内容
	     */
	    get text(): string;
	    set text(value: string);
	    /**
	     *  文本偏移
	     */
	    get textOffsetY(): number;
	    set textOffsetY(value: number);
	    setSelected(value: boolean): void;
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    release(): void;
	    protected onStateChange(label: Button, state: string): void;
	}

}
declare module 'src/display/CheckBox' {
	import { Label } from 'src/display/Label';
	import { Button } from 'src/display/Button';
	/**
	 * 单选\复选框
	 *
	 * 设置checkGroup后，进行分组。 分组后，可理解为复选框。
	 *
	 * @example let checkBox = new vf.gui.CheckBox();
	 *
	 *
	 */
	export class CheckBox extends Button {
	    constructor();
	    /**
	     * 设置值
	     */
	    private _value;
	    /**
	     * 设置是否选中
	     * */
	    private _checked;
	    /**
	     * 获取或设置当前选中的值
	     */
	    get selectedValue(): string | undefined;
	    /**
	     * 设置分组名
	     */
	    get checkGroup(): string | undefined;
	    set checkGroup(value: string | undefined);
	    /**
	     * 获取设置默认值
	     */
	    get value(): string;
	    set value(value: string);
	    /**
	     * 设置是否选中
	     * @default false
	     */
	    get checked(): boolean;
	    set checked(value: boolean);
	    protected onClick(e: any): void;
	    protected onLabelChange(label: Label): void;
	    release(): void;
	}

}
declare module 'src/interaction/InputController' {
	import { DisplayObject } from 'src/core/DisplayObject';
	import { CheckBox } from 'src/display/CheckBox';
	interface CheckGroupObject {
	    groups: {
	        [key: string]: {
	            [value: string]: CheckBox;
	        };
	    };
	    values: {
	        [key: string]: string | undefined;
	    };
	}
	/**
	 *
	 * @private
	 */
	export const tabGroups: {
	    [key: string]: DisplayObject[];
	};
	/**
	 *
	 * @private
	 */
	export const _checkGroupObject: CheckGroupObject;
	/**
	 * 注册组件
	 * @param item
	 * @param tabIndex 切换位置
	 * @param tabGroup 分组名
	 * @returns 依据tabIndex返回是否需要排序 0，-1，1
	 */
	export function registrer(item: DisplayObject, tabIndex: number, tabGroup?: string): void;
	/** 失去焦点时 */
	export function blur(): void;
	/** 设置当前输入组件 */
	export function set(item: DisplayObject): void;
	/** 清楚当前设置的组件 */
	export function clear(): void;
	/** 一般再按下键盘tab健执行 焦点获取与设置 */
	export function fireTab(): void;
	/** 一般再按下键盘向下箭头执行 焦点获取与设置 */
	export function fireNext(): void;
	/** 一般再按下键盘向上箭头执行 焦点获取与设置 */
	export function firePrev(): void;
	/**
	 * 注册分组，一般用于checkBox组件的分组操作
	 *
	 *  ==== 目前没有实现卸载，如果无限制创建checkbox并设置分组可能引发泄露 ====
	 *
	 * checkGroups = [key]:{["value"]:cb}
	 */
	export function registrerCheckGroup(cb: CheckBox): void;
	/**
	 * 注销指定分组或指定分组的子项
	 * @param cb CheckBox
	 */
	export function unRegistrerCheckGroup(cb: CheckBox): void;
	/** 更新分组中选中的checkbox组件  */
	export function updateCheckGroupSelected(cb: CheckBox): void;
	/** 获取分组中选中的checkbox值 */
	export function getCheckGroupSelectedValue(name: string): string | undefined;
	/** 设置选中 */
	export function setCheckGroupSelectedValue(name: string, uuid: string): void;
	export {};

}
declare module 'src/display/Container' {
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 * 基础容器
	 *
	 * 设置checkGroup后，进行分组。 分组后，可理解为复选框。
	 *
	 * @example let container = new vf.gui.Container();
	 *
	 */
	export class Container extends DisplayObject {
	    constructor();
	    /**
	     * 确定指定显示对象是 DisplayObjectContainer 实例的子项或该实例本身。搜索包括整个显示列表（其中包括此 DisplayObjectContainer 实例）。
	     * 孙项、曾孙项等，每项都返回 true。
	     * @param child 要测试的子对象。
	     * @returns 如果 child 对象是 DisplayObjectContainer 的子项或容器本身，则为 true；否则为 false。
	     */
	    contains(child: DisplayObject): boolean;
	}

}
declare module 'src/display/private/GraphicsCore' {
	///   types="@vf.js/vf" />
	/**
	 * 图形逻辑基类
	 */
	export class GraphicsCore extends vf.Graphics {
	    private _lineType;
	    constructor(geometry?: vf.GraphicsGeometry | undefined);
	    private RatioLine;
	    private RatioNone;
	    lineStyle(width?: number, color?: number, alpha?: number, alignment?: number, native?: boolean, lineType?: "full" | "dash"): vf.Graphics;
	    lineTo(x: number, y: number): vf.Graphics;
	    arc(cx: number, cy: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): vf.Graphics;
	    /**
	     * 画椭圆
	    */
	    drawEllipse(xx: number, yy: number, width: number, height: number): vf.Graphics;
	    /**
	     * 圆角矩形
	     */
	    drawRoundedRect(x: number, y: number, width: number, height: number, radius: number): vf.Graphics;
	    /**
	     * 闭合路线
	     */
	    drawPolygonOne(path: vf.Point[], closeStroke?: boolean): vf.Graphics;
	    /**
	     * 判断一个点是否在贝塞尔曲线上
	     * B_{3}(t) = (1 - t)^3P_0 + 3t(1 - t)^2P_1 + 3t^2(1 - t)P_2 + t^3P_3 , t  in[0, 1]
	     *
	     * (x3-3*x2+3*x1-x0)t^3 + (3*x2-6*x1+3*x0)t^2 + (3*x1-3*x0)t + x0
	     *
	     * cpX cpY 控制点一
	     * cpX2 cpY2 控制点二
	     * toX toY 曲线目标点
	     * fromX fromY 曲线起始点
	     * x y 当前点
	     */
	    checOnkBezier(cpX: number, cpY: number, cpX2: number, cpY2: number, toX: number, toY: number, fromX: number, fromY: number, x: number, y: number): number;
	    /**
	     *
	     */
	    quadraticCurveTo(cpX: number, cpY: number, toX: number, toY: number): vf.Graphics;
	    /**
	     * 贝塞尔曲线
	     */
	    bezierCurveTo(cpX: number, cpY: number, cpX2: number, cpY2: number, toX: number, toY: number): vf.Graphics;
	    private drawBezierDash;
	    /**
	    * 获取二阶贝塞尔曲线点信息(近似值 ， n越大值越准确)
	    */
	    quadPointLength(fromX: number, fromY: number, cpX: number, cpY: number, toX: number, toY: number, n?: number): vf.Point[];
	    /**
	     * 获取三阶贝塞尔曲线点信息(近似值 ， n越大值越准确)
	     */
	    bezierPointLength(fromX: number, fromY: number, cpX: number, cpY: number, cpX2: number, cpY2: number, toX: number, toY: number, n?: number): vf.Point[];
	    /**
	     * 根据点取长度
	     */
	    private bezierLength;
	    private bezierToLineData;
	    private pointDistance;
	    /**
	     * 获取线段起始位置或者终止位置角度
	     */
	    getLineRotation(lineTyle: "M" | "L" | "Q" | "C", isBeignPoint: boolean, fromX: number, fromY: number, toX: number, toY: number, cpX?: number, cpY?: number, cpX2?: number, cpY2?: number): number;
	}

}
declare module 'src/display/private/GraphBase' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { MaskSprite } from 'src/core/MaskSprite';
	import { GraphicsCore } from 'src/display/private/GraphicsCore';
	/**
	 * 绘制图形基类
	 */
	export class GraphBase extends DisplayObject implements MaskSprite {
	    constructor();
	    readonly graphics: GraphicsCore;
	    canvas?: HTMLCanvasElement;
	    context?: CanvasRenderingContext2D;
	    texture?: vf.Texture;
	    /** 可以支持遮罩的组件 */
	    maskSprite(): GraphicsCore;
	    /**
	     * 半径
	     */
	    protected _radius: number;
	    get radius(): number;
	    set radius(value: number);
	    /**
	     *
	     */
	    protected _alignment: number;
	    get alignment(): number;
	    set alignment(value: number);
	    /**
	     * 线条样式
	     */
	    protected _lineType: "full" | "dash";
	    get lineType(): "full" | "dash";
	    set lineType(value: "full" | "dash");
	    /**
	     * 线条颜色
	     */
	    protected _lineColor: any;
	    get lineColor(): any;
	    set lineColor(value: any);
	    /**
	     * 线条粗细
	     */
	    protected _lineWidth: number;
	    get lineWidth(): number;
	    set lineWidth(value: number);
	    /**
	     * 线条透明度
	     */
	    protected _lineAlpha: number;
	    get lineAlpha(): number;
	    set lineAlpha(value: number);
	    /**
	     * 填充透明度
	     */
	    protected _fillAlpha: number;
	    get fillAlpha(): number;
	    set fillAlpha(value: number);
	    /**
	     * 颜色
	     */
	    get fillColor(): number[];
	    set fillColor(value: number[]);
	    /**
	     * 颜色
	     */
	    protected _color?: any;
	    get color(): any;
	    set color(value: any);
	    /**
	     * 锚点，调整位图的坐标中点 0-1
	     */
	    get anchorX(): number;
	    set anchorX(value: number);
	    /**
	     * 锚点，调整位图的坐标中点 0-1
	     */
	    get anchorY(): number;
	    set anchorY(value: number);
	    /**
	     * 子类重写
	     */
	    drawGraph(): void;
	    release(): void;
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	}

}
declare module 'src/display/Circle' {
	import { GraphBase } from 'src/display/private/GraphBase';
	/**
	 * 绘制圆形
	 *
	 * 不设置 lineWidth 或 color 圆形不可见
	 *
	 * @example let circle = new vf.gui.Circle();
	 *
	 *
	 */
	export class Circle extends GraphBase {
	    constructor();
	    /**
	     * 开始绘制角度
	     */
	    protected _startAngle: number;
	    get startAngle(): number;
	    set startAngle(value: number);
	    /**
	     * 结束角度
	     */
	    protected _endAngle: number;
	    get endAngle(): number;
	    set endAngle(value: number);
	    /**
	     * 逆时针绘制
	     */
	    protected _anticlockwise: boolean;
	    get anticlockwise(): boolean;
	    set anticlockwise(value: boolean);
	    drawGraph(): void;
	}

}
declare module 'src/display/Star' {
	import { GraphBase } from 'src/display/private/GraphBase';
	export class Star extends GraphBase {
	    constructor();
	    private path;
	    private PI_2;
	    private _triangleNum;
	    private RADIUS_V;
	    private _innerRadius;
	    drawGraph(): void;
	    get triangleNum(): number;
	    set triangleNum(value: number);
	    get innerRadius(): number;
	    set innerRadius(value: number);
	    private setStarPath;
	}

}
declare module 'src/display/Rect' {
	import { GraphBase } from 'src/display/private/GraphBase';
	/**
	 * 绘制矩形或圆角矩形
	 *
	 * 不设置 lineWidth 或 color 矩形不可见
	 *
	 * @example let rect = new vf.gui.Rect();
	 *
	 */
	export class Rect extends GraphBase {
	    constructor();
	    drawGraph(): void;
	}

}
declare module 'src/display/VideoBtn' {
	import { Container } from 'src/display/Container';
	export class VideoBtn extends Container {
	    private _states;
	    private _bgCircle?;
	    private _thumbTriangle?;
	    private _rect1?;
	    private _rect2?;
	    constructor();
	    setStates(states: "play" | "pause"): void;
	    updateDisplayList(): void;
	    private refreshPlay;
	    private refreshPause;
	    private initBgCircle;
	    private onHover;
	    private initTrangle;
	    private initLine;
	    release(): void;
	}

}
declare module 'src/display/Video' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 * 播放器组件
	 *
	 */
	export class Video extends DisplayObject {
	    private _video;
	    private _videoHasEvent;
	    private _src;
	    protected _canvasBounds: {
	        top: number;
	        left: number;
	        width: number;
	        height: number;
	    } | undefined;
	    protected _lastRenderer: vf.Renderer | undefined;
	    protected _resolution: number;
	    private _canplayFun;
	    private _canplaythroughFun;
	    private _completeFun;
	    private _endedFun;
	    private _loadeddataFun;
	    private _durationchangeFun;
	    private _pauseFun;
	    private _playFun;
	    private _autoplay;
	    private _canPlayFirst;
	    private _videoTextrue;
	    private _sprite;
	    private _poster;
	    private _posterImg?;
	    private _videoBtn?;
	    private _firstLoad;
	    private _muted;
	    private _loop;
	    private _controls;
	    private _volume;
	    private _currentTime;
	    private _oldPoster;
	    private _oldSrc;
	    private _canPlay;
	    private _visibleStatus;
	    private _elemDraw;
	    private _isplaying;
	    forceElementDraw: boolean;
	    constructor();
	    private createVideoBtn;
	    private clickAudio;
	    /**
	     *  目前 设置src才会添加sprite到舞台
	     *  创建sprite需要根据src获取纹理
	     */
	    private createVideoSource;
	    private canplayFun;
	    private canplaythroughFun;
	    private completeFun;
	    private pauseFun;
	    private playFun;
	    private endedFun;
	    private loadeddataFun;
	    private checkComatibility;
	    private durationchangeFun;
	    private checkVideoPlay;
	    get x(): number;
	    set x(value: number);
	    get y(): number;
	    set y(value: number);
	    private setPos;
	    private _getCanvasBounds;
	    private updateSystem;
	    private updatePostion;
	    private _lastPostion;
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    private updataPoster;
	    private clearPoster;
	    /**
	     * 支持的参数们~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	     */
	    private _silent;
	    set silent(value: any);
	    get silent(): any;
	    private _audio;
	    set audio(value: any);
	    get audio(): any;
	    get src(): any;
	    set src(value: any);
	    get srcObject(): any;
	    set srcObject(value: any);
	    get autoplay(): boolean;
	    set autoplay(value: boolean);
	    get loop(): boolean;
	    set loop(value: boolean);
	    get poster(): string;
	    set poster(value: string);
	    get muted(): boolean;
	    set muted(boo: boolean);
	    get controls(): boolean;
	    set controls(boo: boolean);
	    get volume(): number;
	    set volume(value: number);
	    get visible(): boolean;
	    set visible(boo: boolean);
	    get videoElement(): HTMLVideoElement;
	    get currentTime(): number;
	    set currentTime(value: number);
	    /**
	     * 设置分组名
	     */
	    get videoGroup(): string | undefined;
	    set videoGroup(value: string | undefined);
	    /**
	     * 只读的属性们~~~~~~~~~~~~~~~~
	     * */
	    get duration(): number;
	    get isPlaying(): boolean;
	    /**
	    * 支持的方法们~~~··~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	    **/
	    play(): void;
	    pause(): void;
	    private _oldX;
	    private _oldY;
	    private _fullStates;
	    requestFullScreen(): void;
	    private fullScreen;
	    private requestFullScreenDom;
	    exitFullscreen(): void;
	    exitFullscreenDom(): void;
	    private clearSource;
	    private clearVideoBtn;
	    private clearVideoEvent;
	    private clearVideo;
	    private clearSprite;
	    private useNativeAudio;
	    private nativeEmit;
	    release(): void;
	}

}
declare module 'src/interaction/VideoGroupController' {
	import { Video } from 'src/display/Video';
	interface VideoGroupObject {
	    groups: {
	        [key: string]: {
	            [value: string]: Video;
	        };
	    };
	    values: {
	        [key: string]: string | undefined;
	    };
	}
	export const _videoGroupObject: VideoGroupObject;
	export function registrerVideoGroup(cb: Video): void;
	/**
	 * 注销指定分组或指定分组的子项
	 * @param cb video
	 */
	export function unRegistrerVideoGroup(cb: Video): void;
	/** 更新分组中选中的checkbox组件  */
	export function updateVideoGroupStates(cb: Video): void;
	export {};

}
declare module 'src/interaction/MouseScrollEvent' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 * 鼠标滑轮事件
	 *
	 *  可侦听事件(未实现):
	 * ```
	 *  {InteractionEvent}.MouseScroll.xxxxxx.
	 * ```
	 *  可赋值方法:
	 * ```
	 * oonMouseScroll: ((e: WheelEvent,delta: vf.Point) => void) | undefined
	 * ```
	 *
	 * @example 可查看 `Slider` 源码
	 *
	 * @since 1.0.0
	 */
	export class MouseScrollEvent {
	    /**
	     *
	     * @param obj 需要绑定的对象
	     * @param preventDefault 是否组织系统默认的事件触发
	     */
	    constructor(obj: DisplayObject, preventDefault: boolean);
	    id: number;
	    private obj;
	    private preventDefault;
	    private delta;
	    private mouseScrllBind;
	    private isStop;
	    startEvent(): void;
	    private _onMouseScroll;
	    private _onHover;
	    private _onMouseOut;
	    stopEvent(): void;
	    remove(): void;
	    onMouseScroll: ((e: WheelEvent, delta: vf.Point) => void) | undefined;
	}

}
declare module 'src/event/ComponentEvent' {
	/**
	 * 特定属性改变时,通常为了去系统事件区分，UI组件的事件名为大写
	 * 1. CheckBox 的 checked 改变时
	 * 2. Label 的 text 改变时
	 * 3. SpriteAnimated 的 animationName 改变时
	 * 4. Button 文字改变
	 * 5. ScrollingContainer 拖动改变时
	 * 6. Slider 滑动改变后
	 * 7. SpriteAnimated 动画改变后
	 * 8. ConnectLine 连线完成时
	 */
	export const CHANGE = "CHANGE";
	/**
	 * 状态改变中
	 *
	 * slider 滑动时
	 */
	export const CHANGEING = "CHANGEING";
	/**
	 * 状态切换完成时
	 *
	 * 1. SpriteAnimated 每次播放完时，触发(loop = false时)
	 * 2. Image 图片加载完成时
	 * 3. Slider 滑动完成
	 * 4. Timeline  每次播放完时，触发(loop = false时)
	 * 5. FollowLine 完成一次划线
	 */
	export const COMPLETE = "COMPLETE";
	/**
	 * 状态发生改变时
	 */
	export const STATE_CHANGE = "STATE_CHANGE";
	/**
	 * 状态切换完成时
	 *
	 * SpriteAnimated 每次播放完时，，触发(loop = true时)
	 */
	export const LOOP = "LOOP";
	/**
	 * 组件被添加前
	 */
	export const ADD = "add";
	/**
	 * 组件被添加时
	 */
	export const ADDED = "added";
	/**
	 * 组件被移除时
	 */
	export const REMOVEED = "removed";
	/**
	 * 组件大小改变后
	 */
	export const RESIZE = "RESIZE";
	/**
	 * 组件位置移动
	 */
	export const MOVE = "MOVE";
	/**
	 * 组件创建完成后
	 */
	export const CREATION_COMPLETE = "CREATION_COMPLETE";
	/**
	 * 拖拽组件按下
	 */
	export const DRAG_DOWN = "DRAG_DOWN";
	/**
	 * 拖拽组件按下
	 */
	export const DRAG_UP = "DRAG_UP";
	/**
	 * 拖拽组件hover
	 */
	export const DRAG_HOVER = "DRAG_HOVER";
	/**
	 * 拖拽组件mouseover
	 */
	export const DRAG_MOUSEENTER = "DRAG_MOUSEENTER";
	/**
	 * 拖拽组件mouseleave
	 */
	export const DRAG_MOUSELEAVE = "DRAG_MOUSELEAVE";
	/**
	 * 组件拖动开始之前
	 */
	export const DRAG_START_BEFORE = "DRAG_START_BEFORE";
	/**
	 * 组件拖动开始时
	 */
	export const DRAG_START = "DRAG_START";
	/**
	 * 组件拖动结束之前
	 */
	export const DRAG_END_BEFORE = "DRAG_END_BEFORE";
	/**
	 * 组件拖动结束时 （如果绑定接收容器并拖动到接收容器中，不会触发此事件）
	 */
	export const DRAG_END = "DRAG_END";
	/**
	 * 组件拖动中
	 */
	export const DRAG_MOVE = "DRAG_MOVE";
	/**
	 * 组件拖动到接收目标中之前
	 */
	export const DRAG_TARGET_BEFORE = "DRAG_TARGET_BEFORE";
	/**
	 * 组件拖动到接收目标中
	 */
	export const DRAG_TARGET = "DRAG_TARGET";
	/**
	 * 有拖拽物掉落到此容器时触发
	 */
	export const DROP_TARGET = "DROP_TARGET";
	/**
	 * 播放音效 {name,mode}
	 */
	export const PLAY_AUDIO = "PLAY_AUDIO";
	/**
	 * 组件宽度发生变化(目前文本换行需要用到)
	 */
	export const WIDTH_CHANGE = "WIDTH_CHANGE";

}
declare module 'src/interaction/GroupController' {
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 *
	 * @private
	 */
	export const _GroupObject: Map<string, {
	    [key: string]: DisplayObject;
	}>;
	/**
	 * 具有ID属性的组件都会添加到本组
	 * @private
	 */
	export const _idObject: Map<string, DisplayObject>;
	export function getObjectById(id: string): DisplayObject | undefined;
	export function registrerID(ui: DisplayObject): boolean;
	export function unRegistrerID(ui: DisplayObject): void;
	/**
	 * 注册分组，
	 */
	export function registrerGroup(ui: DisplayObject): void;
	/**
	 * 注销指定分组或指定分组的子项
	 */
	export function unRegistrerGroup(ui: DisplayObject): void;
	/** 设置选中 */
	export function getGroup(name?: string): {
	    [key: string]: DisplayObject;
	} | undefined;

}
declare module 'src/interaction/Index' {
	import { ClickEvent } from 'src/interaction/ClickEvent';
	import * as DragDropController from 'src/interaction/DragDropController';
	import { DragEvent } from 'src/interaction/DragEvent';
	import * as InputController from 'src/interaction/InputController';
	import * as VideoGroupController from 'src/interaction/VideoGroupController';
	import { MouseScrollEvent } from 'src/interaction/MouseScrollEvent';
	import { InteractionEvent } from 'src/event/InteractionEvent';
	import { TouchMouseEvent } from 'src/event/TouchMouseEvent';
	import * as ComponentEvent from 'src/event/ComponentEvent';
	import * as GroupController from 'src/interaction/GroupController';
	export { ClickEvent, DragDropController, DragEvent, InputController, MouseScrollEvent, InteractionEvent, TouchMouseEvent, ComponentEvent, GroupController, VideoGroupController };

}
declare module 'src/layout/CSSSSystem' {
	/** ===================== mask  ===================== */
	/** ===================== font  ===================== */
	export function updateFontStyle(target: any, key: string, value: any): void;
	export function color(target: any, key: string, value: any): void;
	export function ColorRGBA(target: any, key: "fillColor" | "lineColor", value: number[] | number[][]): void;
	export function lineWidth(target: any, key: "lineWidth", value: number): void;

}
declare module 'src/enum/TracingEnum' {
	export const enum Operate {
	    Add = 0,
	    Clear = 1,
	    Remove = 2
	}
	export const enum Mode {
	    Check = 0,
	    Teach = 1,
	    Auto = 2,
	    Strict = 3,
	    Fill = 4
	}
	export const enum Result {
	    Uncomplete = 0,
	    Correct = 1,
	    Incorrect = 2,
	    Complete = 3
	}

}
declare module 'src/enum/FontWeight' {
	/** 字体粗细 */
	export const enum FontWeight {
	    'normal' = "normal",
	    'bold' = "bold",
	    'bolder' = "bolder",
	    'lighter' = "lighter",
	    'n100' = 100,
	    'n200' = 200,
	    'n300' = 300,
	    'n400' = 400,
	    'n500' = 500,
	    'n600' = 600,
	    'n700' = 700,
	    'n800' = 800,
	    'n900' = 900
	}

}
declare module 'src/enum/Index' {
	import * as FollowLineEnum from 'src/enum/FollowLineEnum';
	import * as TracingEnum from 'src/enum/TracingEnum';
	export { FontWeight } from 'src/enum/FontWeight';
	export { FollowLineEnum, TracingEnum };

}
declare module 'src/layout/CSSStyle' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { FontWeight } from 'src/enum/Index';
	/**
	 * 	定位方式
	 *
	 *  元素的位置通过 "left", "top", "right" 以及 "bottom" 属性进行规定。
	 *
	 * 	absolute 生成绝对定位的元素，相对于第一个父元素进行定位。
	 *
	 *  fixed 生成绝对定位的元素，相对于舞台进行定位。
	 *
	 *  static 没有定位，元素出现在正常的流中（忽略 top, bottom, left, right 或者 z-index 声明）。
	 */
	export type Position = "absolute" | "fixed" | "static";
	/** 对齐方式 父级如果是grid布局，会忽略当前居中模式 */
	export type Align = "flex-start" | "flex-end" | "center";
	/** 布局模式 */
	export type Display = "none" | "block" | "grid";
	/**
	 * 组件样式表
	 */
	export class CSSStyle {
	    constructor(target: DisplayObject);
	    parent: DisplayObject;
	    release(): void;
	    /**
	     * 规定元素的显示类型。布局模式
	     *
	     * grid 模式下，子节点会忽略left,top,right，bottom,width,height等
	     *
	     * none 模式下，忽略style
	     * */
	    private _display;
	    get display(): Display;
	    set display(value: Display);
	    /**
	     * 规定元素的定位类型。
	     * */
	    private _position;
	    get position(): Position;
	    set position(value: Position);
	    /**
	     * 在容器里面的水平位置（左中右）
	     */
	    private _justifyContent?;
	    get justifyContent(): "center" | "flex-start" | "flex-end" | undefined;
	    set justifyContent(value: "center" | "flex-start" | "flex-end" | undefined);
	    /**
	     * 在容器里面的垂直位置（上中下）
	     */
	    private _alignContent?;
	    get alignContent(): "center" | "flex-start" | "flex-end" | undefined;
	    set alignContent(value: "center" | "flex-start" | "flex-end" | undefined);
	    /**
	     * 基于 网格列的维度，去定义网格线的名称和网格轨道的尺寸大小。
	     *
	     * 方式一 [80,90,100]|["30%","40%","30%"] 第一列宽度80，第二列宽度，第三列宽度100
	     *
	     * 方式二 ["repeat",3,100] 三列，宽度都为100像素
	     */
	    private _gridTemplateColumns?;
	    get gridTemplateColumns(): number[] | string[] | [string, number, number] | undefined;
	    set gridTemplateColumns(value: number[] | string[] | [string, number, number] | undefined);
	    /**
	     * 设置列间距
	     */
	    private _gridColumnGap?;
	    get gridColumnGap(): number | undefined;
	    set gridColumnGap(value: number | undefined);
	    /**
	     * 基于 网格行的维度，去定义网格线的名称和网格轨道的尺寸大小。
	     *
	     * 方式一 [80,90,100]|["30%","40%","30%"] 第一行高度80，第二行高度90，第三行行高度100
	     *
	     * 方式二 ["repeat",3,100] 三行，宽度都为100像素
	     */
	    private _gridTemplateRows?;
	    get gridTemplateRows(): number[] | string[] | [string, number, number] | undefined;
	    set gridTemplateRows(value: number[] | string[] | [string, number, number] | undefined);
	    /**
	     * 设置行间距
	     */
	    private _gridRowGap?;
	    get gridRowGap(): number | undefined;
	    set gridRowGap(value: number | undefined);
	    /**
	     * 表示显示对象的宽度，以像素为单位。
	     * */
	    get width(): number | string;
	    set width(value: number | string);
	    /**
	     * 表示显示对象的高度，以像素为单位。
	     * */
	    get height(): number | string;
	    set height(value: number | string);
	    /**
	     * 设置元素的最小宽度。
	     */
	    get minWidth(): number;
	    set minWidth(value: number);
	    /**
	     * 设置元素的最大宽度。
	     */
	    get maxWidth(): number;
	    set maxWidth(value: number);
	    /**
	     * 设置元素的最小高度。
	     */
	    get maxHeight(): number;
	    set maxHeight(value: number);
	    /**
	     * 设置元素的最大高度。
	     * */
	    get minHeight(): number;
	    set minHeight(value: number);
	    /**
	     * 设置定位元素左外边距边界与其容器左边界之间的偏移。
	     * */
	    get left(): any;
	    set left(value: any);
	    /**
	     * 设置定位元素的上外边距边界与其容器上边界之间的偏移。
	     * */
	    get top(): any;
	    set top(value: any);
	    /**
	     * 设置定位元素右外边距边界与其容器右边界之间的偏移。
	     * */
	    get right(): any;
	    set right(value: any);
	    /**
	     * 设置定位元素下外边距边界与其容器下边界之间的偏移。
	     * */
	    get bottom(): any;
	    set bottom(value: any);
	    /**
	     * 缩放
	     * */
	    get scaleX(): number;
	    set scaleX(value: number);
	    /**
	     * 缩放
	     * */
	    get scaleY(): number;
	    set scaleY(value: number);
	    /**
	     * 设置元素水平拉伸扭曲（角度）。
	     * */
	    get skewX(): number;
	    set skewX(value: number);
	    /**
	     * 设置元素垂直拉伸扭曲（角度）。
	     * */
	    get skewY(): number;
	    set skewY(value: number);
	    /**
	     * 设置元素旋转 （角度）
	    */
	    get rotate(): number;
	    set rotate(value: number);
	    /**
	     * 设置元素旋转 （角度）
	    */
	    get rotation(): number;
	    set rotation(value: number);
	    /**
	     * 轴点 像素值
	     */
	    get pivotX(): number;
	    set pivotX(value: number);
	    /**
	     * 轴点 像素值
	     */
	    get pivotY(): number;
	    set pivotY(value: number);
	    /**
	      * 调整元素的色调，取消设置0xFFFFFF
	      */
	    get tint(): number;
	    set tint(value: number);
	    /**
	     * 表示指定对象的 Alpha 透明度值。有效值为0（完全透明）～ 1（完全不透明）。
	     * */
	    get alpha(): number;
	    set alpha(value: number);
	    /**
	     * 显示对象是否可见
	     * */
	    get visible(): boolean;
	    set visible(value: boolean);
	    get visibility(): "visible" | "hidden";
	    set visibility(value: "visible" | "hidden");
	    /**
	     * 设置元件的背景颜色。（16进制数字0xffffff
	     * */
	    get backgroundColor(): number | number[] | number[][] | undefined;
	    set backgroundColor(value: number | number[] | number[][] | undefined);
	    /**
	     * 设置元素的背景圆角
	     */
	    get backgroundRadius(): number;
	    set backgroundRadius(value: number);
	    /**
	     * 设置元素的背景图像。backgroundImage = "./xxx.png"
	     * */
	    get backgroundImage(): string | undefined;
	    set backgroundImage(value: string | undefined);
	    /**
	     * 设置 backgroundImage 后 ，设置背景图像的X位置
	     * */
	    get backgroundPositionX(): number;
	    set backgroundPositionX(value: number);
	    /**
	     * 设置 backgroundImage 后 ，设置背景图像的Y位置
	     * */
	    get backgroundPositionY(): number;
	    set backgroundPositionY(value: number);
	    /**
	     * 设置 backgroundImage 后， 规定背景图像的尺寸。 [width,height]
	     * */
	    get backgroundSize(): number[] | undefined;
	    set backgroundSize(value: number[] | undefined);
	    /**
	     * 设置 backgroundImage 后，设置是否及如何重复背景图像。
	     * repeat重复
	     * no-repeat不重复，
	     */
	    get backgroundRepeat(): "repeat" | "no-repeat";
	    set backgroundRepeat(value: "repeat" | "no-repeat");
	    /**
	     * 设置背景透明度
	     */
	    get backgroundAlpha(): number;
	    set backgroundAlpha(value: number);
	    /**
	     * 遮罩图
	     */
	    get maskImage(): string | vf.Graphics | import("../core/MaskSprite").MaskSprite | undefined;
	    set maskImage(value: string | vf.Graphics | import("../core/MaskSprite").MaskSprite | undefined);
	    /**
	     * 设置位数 [x,y]
	     */
	    get maskPosition(): number[] | undefined;
	    set maskPosition(value: number[] | undefined);
	    /**
	     * 设置遮罩位图的大小
	     */
	    get maskSize(): number[] | undefined;
	    set maskSize(value: number[] | undefined);
	    /**
	     * 设置滤镜
	     */
	    get filter(): any;
	    set filter(value: any);
	    /**
	     * 设置鼠标样式
	     */
	    get cursor(): string;
	    set cursor(value: string);
	    /**
	     * 填充颜色，后面取代Color
	     * 数组形式 [r,g,b,a]
	     */
	    private _fillColor;
	    get fillColor(): number[] | number[][];
	    set fillColor(value: number[] | number[][]);
	    /**
	     * 支持：图形
	     * 边框线条颜色
	     * 数组形式 [r,g,b,a]
	     */
	    private _lineColor;
	    get lineColor(): number[];
	    set lineColor(value: number[]);
	    /**
	     * 支持：图形
	     * 边框线条宽度
	     */
	    private _lineWidth;
	    get lineWidth(): number;
	    set lineWidth(value: number);
	    /**
	     * 文本颜色
	     * 16进制RGB 0xffffff ｜ 16777215
	     * 数组形式 [r,g,b,a]
	     *
	     * 默认白色
	     * */
	    private _color?;
	    get color(): string | number | number[] | string[] | undefined;
	    set color(value: string | number | number[] | string[] | undefined);
	    /** 字符间距 */
	    private _letterSpacing?;
	    get letterSpacing(): number | undefined;
	    set letterSpacing(value: number | undefined);
	    /**
	     * 是否自动换行
	     * */
	    private _wordWrap;
	    get wordWrap(): boolean;
	    set wordWrap(value: boolean);
	    /**
	     * 自动换行的宽度
	     * */
	    private _wordWrapWidth?;
	    get wordWrapWidth(): any;
	    set wordWrapWidth(value: any);
	    /**
	     * 下划线类型
	     * */
	    private _textDecoration;
	    get textDecoration(): "None" | "Overline" | "LineThrough" | "UnderLine";
	    set textDecoration(value: "None" | "Overline" | "LineThrough" | "UnderLine");
	    /**
	    * 下划线颜色
	    * */
	    private _textDecorationColor;
	    get textDecorationColor(): number;
	    set textDecorationColor(value: number);
	    /**
	     * 多行文本(wordWrap = true) - 对齐方式
	     * */
	    private _textAlign;
	    get textAlign(): "left" | "right" | "center";
	    set textAlign(value: "left" | "right" | "center");
	    /**
	     * 多行文本(wordWrap = true) - 垂直对齐方式
	     * */
	    private _verticalAlign;
	    get verticalAlign(): "top" | "bottom" | "middle";
	    set verticalAlign(value: "top" | "bottom" | "middle");
	    /**
	     * 多行文本(wordWrap = true) - 行高
	     * */
	    private _lineHeight?;
	    get lineHeight(): number | undefined;
	    set lineHeight(value: number | undefined);
	    /** 字体 示例：fontFamily = "\"Comic Sans MS\", cursive, sans-serif" */
	    private _fontFamily?;
	    private _whiteFamily;
	    get fontFamily(): string | string[] | undefined;
	    set fontFamily(value: string | string[] | undefined);
	    /** 字体大小 */
	    private _fontSize;
	    get fontSize(): number;
	    set fontSize(value: number);
	    /** 字体样式 */
	    private _fontStyle;
	    get fontStyle(): "normal" | "italic" | "oblique";
	    set fontStyle(value: "normal" | "italic" | "oblique");
	    /**  字体变形，普通或小写  */
	    private _fontVariant;
	    get fontVariant(): "normal" | "small-caps";
	    set fontVariant(value: "normal" | "small-caps");
	    private _fontWeight;
	    /**
	     * 字体粗细
	     * 枚举 vf.gui.enum.FontWeight
	     * */
	    get fontWeight(): FontWeight;
	    set fontWeight(value: FontWeight);
	    /** 内部填充,只支持文字 */
	    private _padding?;
	    get padding(): number | undefined;
	    set padding(value: number | undefined);
	    /** 描边颜色 */
	    private _stroke?;
	    get stroke(): string | number | number[] | undefined;
	    set stroke(value: string | number | number[] | undefined);
	    /** 描边的笔触粗细值 */
	    private _strokeThickness;
	    get strokeThickness(): number;
	    set strokeThickness(value: number);
	    /** 是否设置投影 */
	    private _dropShadow;
	    get dropShadow(): boolean;
	    set dropShadow(value: boolean);
	    /** 投影的alpha值 */
	    private _dropShadowAlpha;
	    get dropShadowAlpha(): boolean;
	    set dropShadowAlpha(value: boolean);
	    /** 是否设置投影 */
	    private _dropShadowAngle;
	    get dropShadowAngle(): number;
	    set dropShadowAngle(value: number);
	    /** 投影的模糊半径 */
	    private _dropShadowBlur;
	    get dropShadowBlur(): number;
	    set dropShadowBlur(value: number);
	    /** 投影填充颜色值 */
	    private _dropShadowColor;
	    get dropShadowColor(): string | number | number[] | undefined;
	    set dropShadowColor(value: string | number | number[] | undefined);
	    /** 投影深度 */
	    private _dropShadowDistance;
	    get dropShadowDistance(): number;
	    set dropShadowDistance(value: number);
	    /**
	     * 渐变类型
	     *  0 = 垂直渐变
	     *  1 = 水平渐变
	     */
	    private _fillGradientType;
	    get fillGradientType(): 0 | 1;
	    set fillGradientType(value: 0 | 1);
	    /** 渐变区间 */
	    private _fillGradientStops;
	    get fillGradientStops(): number[];
	    set fillGradientStops(value: number[]);
	    /** 中文换行 */
	    private _breakWords;
	    get breakWords(): boolean;
	    set breakWords(value: boolean);
	}

}
declare module 'src/layout/CSSBasicLayout' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	export const $tempRectangle: vf.Rectangle;
	/**
	 * 布局尺寸>外部显式设置尺寸>测量尺寸 的优先级顺序返回尺寸
	 */
	export function formatRelative(value: number | string | undefined, total: number): number;
	/**
	 * @private
	 * 一个工具方法，使用BasicLayout规则布局目标对象。
	 */
	export function updateBasicDisplayList(target: DisplayObject | undefined, unscaledWidth: number, unscaledHeight: number): void;

}
declare module 'src/layout/CSSGridLayout' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 *  更新网格布局
	 *
	 * 单位目前只支持数值或百分比：100 ，”100%“
	 *
	 *  网格布局中，子容器的位置与宽高可能失效
	 *
	 * 关于grid布局的词汇表
	 *
	 * 格网 https://developer.mozilla.org/zh-CN/docs/Glossary/Grid
	 *
	 * 网格行 gridTemplateRows https://developer.mozilla.org/zh-CN/docs/Web/CSS/grid-template-columns
	 *
	 * 网格列 gridTemplateColumns https://developer.mozilla.org/zh-CN/docs/Web/CSS/grid-template-rows
	 *
	 * 网格行间距 gridRowGap   https://developer.mozilla.org/zh-CN/docs/Web/CSS/grid-row-gap
	 *
	 * 网格列间距 gridColumnGap  https://developer.mozilla.org/zh-CN/docs/Web/CSS/grid-column-gap
	 *
	 * 网格轴 （未实现） 支持居中方式为：justifyContent，alignContent
	 *
	 * 网格线（未实现） https://developer.mozilla.org/en-US/docs/Glossary/Grid_Lines
	 *
	 * 网格面积（未实现）https://developer.mozilla.org/zh-CN/docs/Glossary/Grid_Areas
	 */
	export function updateGridLayout(target: DisplayObject): vf.Rectangle;

}
declare module 'src/layout/CSSLayout' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { DisplayLayoutAbstract } from 'src/core/DisplayLayoutAbstract';
	export const $TempyAlignRectangle: vf.Rectangle;
	export const $TempLayoutRectangle: vf.Rectangle;
	export const $TempMeasureRectangle: vf.Rectangle;
	/**
	 * @private
	 * 一个工具方法，使用BasicLayout规则测量目标对象。
	 */
	export function measure(target: DisplayLayoutAbstract): void;
	/**
	 * 调整目标的元素的大小并定位这些元素。
	 */
	export function updateDisplayLayout(target: DisplayObject, unscaledWidth: number, unscaledHeight: number): void;

}
declare module 'src/core/plugs/UIBaseDrag' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { InteractionEvent } from 'src/interaction/Index';
	import { DisplayObjectAbstract } from 'src/core/DisplayObjectAbstract';
	import { Stage } from 'src/core/Stage';
	/**
	 *  组件的拖拽操作
	 *
	 */
	export class UIBaseDrag implements Lifecycle {
	    /**
	     * 构造函数
	     */
	    constructor(target: DisplayObject);
	    static key: string;
	    private target;
	    $targetParent: DisplayObject | Stage | undefined;
	    private oldInteractiveChildren;
	    /**
	     * 可拖动初始化
	     *  @default
	     */
	    private dragInitialized;
	    /**
	     * 可被掉落初始化
	     * @default
	    */
	    private dropInitialized;
	    /**
	     * 拖动控制类
	     */
	    private drag;
	    /**
	     * 临时属性，为了解决同步时的动作补齐
	     * 0 没有操作
	     * 1 开始拖动
	     * 2 拖动中
	     * 3 拖动结束
	     * 4 拖动到目标
	     */
	    private _dragState;
	    /**
	     * 位置
	     *
	     */
	    private _dragPosition;
	    /**
	     * 掉落容器的位置
	     */
	    private _dropPosition;
	    /**
	     * 开始的偏移量
	     */
	    private _startOffset;
	    /**
	     * 是否拖动中
	     * @default
	     */
	    dragging: boolean;
	    /**
	     * 当前拖动组件的事件ID，用于处理DragDropController中多组件的选定
	     */
	    get dragDropEventId(): number | undefined;
	    /**
	     * 是否开启拖动
	     * @default false
	     */
	    set draggable(value: boolean);
	    /**
	     * 是否碰撞检测
	     */
	    collision: boolean;
	    /**
	     * 是否设置边界
	     * @default false
	     */
	    dragBoundary: boolean;
	    /**
	     * 是否启用回弹，在移动到非接收方时，回弹到原始位置
	     */
	    dragBounces: boolean;
	    /**
	     * 拖拽时的鼠标状态
	     */
	    dragMoveCursor: string;
	    /**
	     * 限制拖动抽,XY,X抽或Y抽
	     */
	    private _dragRestrictAxis?;
	    get dragRestrictAxis(): "x" | "y" | undefined;
	    set dragRestrictAxis(value: "x" | "y" | undefined);
	    /**
	     * 拖动分组
	     */
	    get dragGroup(): string;
	    set dragGroup(value: string);
	    /**
	     * 拖动时，物体临时的存放容器，设置后，请注意事件流
	     */
	    private _dragContainer;
	    get dragContainer(): DisplayObjectAbstract | undefined;
	    set dragContainer(value: DisplayObjectAbstract | undefined);
	    /**
	     * 是否开启拖动掉落接收
	     */
	    set droppable(value: boolean | undefined);
	    /**
	     * 接收掉落的新容器
	     */
	    private _droppableReparent;
	    get droppableReparent(): DisplayObject | undefined;
	    set droppableReparent(value: DisplayObject | undefined);
	    /**
	     * 接收拖动掉落的分组名
	     */
	    private _dropGroup;
	    set dropGroup(value: string);
	    get dropGroup(): string;
	    protected clearDraggable(): void;
	    private oldWorldTransform;
	    private oldLocalTransform;
	    protected initDraggable(): void;
	    protected checkCollision(e: InteractionEvent): void;
	    protected checkBump(origin: vf.Rectangle, target: vf.Rectangle): boolean;
	    protected clearDroppable(): void;
	    protected initDroppable(): void;
	    onDrop(e: InteractionEvent): void;
	    /**
	     * 同步数据临时的方法
	     */
	    private executeDrop;
	    load(): void;
	    release(): void;
	}

}
declare module 'src/core/plugs/UIClick' {
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 *  组件的单击操作
	 *
	 */
	export class UIClick implements Lifecycle {
	    /**
	     * 构造函数
	     */
	    constructor(target: DisplayObject);
	    static key: string;
	    private _target;
	    private _clickEvent;
	    set double(value: boolean);
	    get double(): boolean;
	    load(): void;
	    release(): void;
	}

}
declare module 'src/core/plugs/HitArea' {
	import { DisplayObject } from 'src/core/DisplayObject';
	export class HitArea implements Lifecycle {
	    private _type;
	    private _x;
	    private _y;
	    private _width;
	    private _height;
	    private _sprite;
	    private _displayObj;
	    private _drawShape?;
	    /**
	     * 构造函数
	     */
	    constructor(target: DisplayObject);
	    static key: string;
	    get type(): "rect" | "ellipse";
	    set type(value: "rect" | "ellipse");
	    get x(): number;
	    set x(value: number);
	    get y(): number;
	    set y(value: number);
	    get width(): number;
	    set width(value: number);
	    get height(): number;
	    set height(value: number);
	    updataHitArea(): void;
	    private getHitArea;
	    load(): void;
	    release(): void;
	}

}
declare module 'src/core/DisplayObject' {
	///   types="@vf.js/vf" />
	import { DisplayLayoutAbstract } from 'src/core/DisplayLayoutAbstract';
	import { CSSStyle } from 'src/layout/CSSStyle';
	import { UIBaseDrag } from 'src/core/plugs/UIBaseDrag';
	import { HitArea } from 'src/core/plugs/HitArea';
	/**
	 * UI的顶级类，基础的UI对象
	 *
	 * @class
	 * @since 1.0.0
	 */
	export class DisplayObject extends DisplayLayoutAbstract implements Lifecycle {
	    /**
	     * 构造函数
	     */
	    constructor();
	    /**
	     * 插件列表
	     */
	    plugs: Map<string, Lifecycle>;
	    /**
	     * 拖动限制门槛,小于设置的数不执行拖动,防止点击与滚动
	     */
	    dragThreshold: number;
	    /** 拖动时，事件流是否继续传输 */
	    dragStopPropagation: boolean;
	    /** 模糊 */
	    private blurFilter?;
	    /** 子类实现 */
	    _anchorX: number;
	    /** 子类实现 */
	    _anchorY: number;
	    /**
	     * 设置拖动
	     */
	    get dragOption(): UIBaseDrag;
	    set dragOption(value: UIBaseDrag);
	    /** 是否开启鼠标或触摸点击，开启后，接收TouchMouseEvent */
	    get interactabled(): boolean;
	    set interactabled(value: boolean);
	    /**
	     * 设置拖拽
	     */
	    get hitArea(): HitArea;
	    checkHitArea(): boolean;
	    /** 是否开启鼠标或触摸点击，开启后，接收TouchMouseEvent */
	    get isClick(): boolean;
	    set isClick(value: boolean);
	    /**
	     * 分组
	     */
	    protected _groupName?: string;
	    get groupName(): string | undefined;
	    set groupName(value: string | undefined);
	    /**
	     * 透明度
	     */
	    get alpha(): number;
	    set alpha(value: number);
	    /**
	     * 色调
	     * @default 0xFFFFFF
	     * */
	    protected _tint: number;
	    get tint(): number;
	    set tint(value: number);
	    /**
	     * 混合模式
	     */
	    private _blendMode;
	    get blendMode(): vf.BLEND_MODES | undefined;
	    set blendMode(value: vf.BLEND_MODES | undefined);
	    private _filterProxy;
	    private _filterMap;
	    private _filterCount;
	    get filter(): any;
	    /**
	     * 设置Blur XY的模糊强度
	     *
	     * 参数类型为number时，设置 blurX = blurY = value
	     *
	     */
	    set filterBlur(value: number);
	    get filterBlur(): number;
	    /**
	     * 设置灰度
	     *
	     * 参数类型为 number, 接收一个百分比值，然后再将其转换为小数
	     */
	    private grayscaleFilter?;
	    private grayscaleFilterValue;
	    set filterGrayscale(value: number);
	    get filterGrayscale(): number;
	    /**
	     * 私有样式代理
	     * */
	    protected _style?: CSSStyle;
	    /**
	    *  在不同分辨率下保持像素稳定
	    * @default
	    */
	    pixelPerfect: boolean;
	    /**
	     * 动态属性，避免其他类注入
	     */
	    attach: {
	        [key: string]: object | number | string | Function;
	    };
	    /**
	     * 获取样式
	     */
	    get style(): CSSStyle;
	    set style(value: CSSStyle);
	    toDomRectangle(): vf.Rectangle;
	    /**
	     * 更新显示列表,子类重写，实现布局
	     */
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    load(): void;
	    release(): void;
	    releaseAll(): void;
	}

}
declare module 'src/utils/GraphicsUtils' {
	export function parseValues(args: any): any;
	export function vectorAngle(ux: any, uy: any, vx: any, vy: any): number;
	export function getArcCenter(px: number, py: number, cx: number, cy: number, rx: number, ry: number, largeArcFlag: number, sweepFlag: number, sinphi: number, cosphi: number, pxp: number, pyp: number): number[];
	export function approxUnitArc(ang1: number, ang2: number): {
	    x: number;
	    y: number;
	}[];
	export function mapToEllipse(data: {
	    x: number;
	    y: number;
	}, rx: number, ry: number, cosphi: number, sinphi: number, centerx: number, centery: number): {
	    x: number;
	    y: number;
	};
	export function arcToBezier(px: number, py: number, cx: number, cy: number, rx: number, ry: number, xAxisRotation?: number, largeArcFlag?: number, sweepFlag?: number): {
	    x1: number;
	    y1: number;
	    x2: number;
	    y2: number;
	    x: number;
	    y: number;
	}[];
	/**
	 * svg格式拆数组格式
	 * cmds
	(4) [Array(3), Array(8), Array(8), Array(1)]
	0: (3) ["M", 280, 250]
	1: (8) ["A", 200, 200, 0, 1, 1, 680, 250]
	2: (8) ["A", 200, 200, 0, 1, 1, 280, 250]
	3: ["Z"]
	length: 4
	 */
	export function parser(path: any): any;
	export function q2b(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): number[];
	/**
	 * 解析svg的path
	 *
	 *
	    M = moveto
	    L = lineto
	    H = horizontal lineto
	    V = vertical lineto
	    C = curveto
	    S = smooth curveto
	    Q = quadratic Belzier curve
	    T = smooth quadratic Belzier curveto
	    A = elliptical Arc
	    Z = closepath
	    以上所有命令均允许小写字母。大写表示绝对定位，小写表示相对定位(从上一个点开始)。
	 */
	export function parseSvgData(path: string): never[][];
	export function toSVGString(shapes: any): any;

}
declare module 'src/utils/ObjectPool' {
	 class ObjectPool {
	    constructor();
	    /**
	     * 作为对象池的词典dict
	     */
	    private objPoolDict;
	    /**
	     * 向对象池中放入对象，以便重复利用
	     */
	    push<T extends Lifecycle, S>(keyClass: S, oldObj: T): void;
	    /**
	     * 从对象池中取出需要的对象
	     * @return 取出的相应对象
	     *
	     */
	    pop<T>(keyClass: T): any;
	}
	/**
	 * 对象池实例
	 */
	export const objectPoolShared: ObjectPool;
	export {};

}
declare module 'src/utils/calculateUpdatePlayerSize' {
	///   types="@vf.js/vf" />
	import { Stage } from 'src/core/Stage';
	export const enum ScaleMode {
	    SHOW_ALL = "showAll",
	    NO_SCALE = "noScale",
	    COVER = "cover",
	    CONTAIN = "contain",
	    FIXEDHEIGHT = "fixedHeight",
	    FIXEDWIDTH = "fixedWidth"
	}
	export function getBoundingClientRect(dom: HTMLElement): DOMRect;
	/**
	 * @private
	 *
	 * 更新播放器视口尺寸
	 *
	 * noScale 不对内容进行任何缩放，保持原始的1:1比例。如果播放器窗口比内容小，则可能进行一些裁切。
	 *
	 * showAll 非溢出居中，显示全部内容。水平或垂直“两侧”可能会不够宽而留有黑边。
	 *
	 * contain 非溢出，显示全部内容，水平或垂直“一侧”方向有黑边。
	 *
	 * cover 溢出居中，某些部分也许无法显示在播放器视口。
	 */
	export function calculateUpdatePlayerSize(scrennDiv: HTMLElement, app: vf.Application, stage: Stage, stageW: number, stageH: number, scaleMode: ScaleMode): {
	    width: number;
	    height: number;
	    scaleX: number;
	    scaleY: number;
	};

}
declare module 'src/utils/setInteractiveElement' {
	/**
	 * 设置事件绑定目标
	 * @param stage
	 * @param parame
	 */
	export function setInteractiveElement(stage: vf.gui.Stage, parame: {
	    className: string;
	    defaultPointer: string;
	    htmlElement?: HTMLElement;
	    resolution?: number;
	}): void;

}
declare module 'src/utils/cacheDestroy' {
	export function cacheDestroy(res: any, bool: boolean): void;

}
declare module 'src/utils/Utils' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { Stage } from 'src/core/Stage';
	import { DisplayObjectAbstract } from 'src/core/DisplayObjectAbstract';
	export * from 'src/utils/ObjectPool';
	export * from 'src/utils/calculateUpdatePlayerSize';
	export * from 'src/utils/setInteractiveElement';
	export * from 'src/utils/cacheDestroy';
	/**
	 * 是否调试模式
	 */
	export let debug: boolean;
	/**
	 * 工具类
	 */
	/** 日志输出 */
	export function log(message?: string | number | object, ...optionalParams: string[] | number[] | object[]): void;
	/**
	 * 组件获取资源 - 源路径,外部可以重写本方法
	 */
	export let $getSourcePath: Function;
	export function setSourcePath(params: (path: any, cls?: any) => {}): void;
	/**
	 * 根据显示路径，获取显示对象
	 */
	export let $getUIDisplayObjectPath: Function;
	export function setDisplayObjectPath(params: (cls?: any, target?: DisplayObject) => {}): void;
	export function getSource(src: any): any;
	export function getTexture(src: any): any;
	export function getSheet(src: any): any;
	export function getSound(src: any): any;
	export function getDisplayObject(src: any, target?: DisplayObject): any;
	/**
	 * 递归获取舞台，组件必须已经添加到舞台
	 * @param DisplayObject
	 */
	export function getStage(target: DisplayObject | DisplayObjectAbstract | Stage): Stage | undefined;
	/**
	 * 获取显示对象的路径(解析json需要的id，并不是uuid)
	 * @param target
	 * @param ids
	 */
	export function getDisplayPathById(target: DisplayObject | DisplayObjectAbstract | Stage, ids?: string[]): string[];
	/**
	 * 快速设置矩形
	 * @param sourcr
	 * @param x
	 * @param y
	 * @param w
	 * @param h
	 */
	export function setRectangle(source: vf.Rectangle, x: number, y: number, w: number, h: number): void;
	/** 获取当前运行时时间 */
	export function now(): number;
	/**
	 * 深度拷贝对象
	 * @param source 对象元
	 */
	export function deepCopy(source: any, target?: any): any;
	/**
	 * helper function to convert string hex to int or default
	 *
	 * 16进制转int，颜色转换
	 * @param str 要转换的值，如#FFFFFF,0xFFFFFF
	 * @param def 转换失败的返回值
	 */
	export function hexToInt(str?: string | number, def?: any): any;
	/**
	 * helper function to convert string hex to int or default
	 *
	 * 16进制转int，颜色转换
	 * @param str 要转换的值，如#FFFFFF,0xFFFFFF
	 * @param def 转换失败的返回值
	 */
	export function hexListToIntList(str?: string | number | string[] | number[], def?: any): any;
	/**
	 *
	 * @param hex 16进制字符窜 如 #FFFFFF ，不能省略三位写法
	 * @param alpha 透明度
	 * @returns "rgba(255,255,255,1)" || false
	 */
	export function hexToRgba(hex: string, alpha: number): string | false;
	/**
	 * 转换为16位字符串，不够2位的补0，如 “01”
	 * @param c 要转换的数字
	 */
	export function componentToHex(c: number): string;
	/**
	 * RGB转16进制
	 * @param r 红 0-255
	 * @param g 绿 0-255
	 * @param b 蓝 0-255
	 */
	export function rgbToHex(r: number, g: number, b: number): string;
	/**
	 * RGB转number
	 * @param r 红 0-255
	 * @param g 绿 0-255
	 * @param b 蓝 0-255
	 */
	export function rgbToNumber(r: number, g: number, b: number): number;
	/**
	 * rgb字符串形式转换
	 * @param color rgb(255,255,255)
	 */
	export function rgbStrToNumber(color: string): number;
	/**
	 * 10进制转RGB
	 * @param c 数
	 */
	export function numberToRgb(c: number): {
	    r: number;
	    g: number;
	    b: number;
	};
	/**
	 * hex 转 RGB，
	 *
	 * 如hex字符串: "#ffffff"->255,255,255
	 *
	 * 如16进制数字: 0xffffff->255,255,255
	 * @param hex
	 */
	export function hexToRgb(hex?: string | number): {
	    r: number;
	    g: number;
	    b: number;
	};
	/**
	 * 根据amt计算当前的位置start-stop，两数差值
	 * @param start 开始数值
	 * @param stop  结束的数值
	 * @param amt 0-1 用时 >1为1，小于0为0
	 */
	export function Lerp(start: number, stop: number, amt: number): number;
	/**
	 * 四舍五入保留指定位数的小数
	 * @param num 取舍的数
	 * @param decimals 保留小数位
	 */
	export function Round(num: number, decimals: number): number;
	/** 获取全局唯一数 */
	export function uid(): number;
	/** 获取URL参数 */
	export function getQueryVariable(variable: string): string | null | undefined;
	/**
	 * 解析一个字符串函数的参数，如xxx(1) = 1
	 * @param
	 */
	export function getStringFunctionParam(str: string): {
	    key: string;
	    value: number;
	};
	export function isDeltaIdentity(m: vf.Matrix): boolean;
	/**
	 * 格式化一个百分比为小数
	 * @param value
	 * @param total
	 */
	export function formatRelative(value: number | string | undefined, total: number): number;
	/** 计算两点距离 */
	export function pointDistance(pointA: vf.Point | {
	    x: number;
	    y: number;
	}, pointB: vf.Point | {
	    x: number;
	    y: number;
	}): number;
	/** 坐标相减 */
	export function pointSub(source: vf.Point | {
	    x: number;
	    y: number;
	}, subPoint: vf.Point | {
	    x: number;
	    y: number;
	}): {
	    x: number;
	    y: number;
	};
	/** 坐标相加 */
	export function pointPlus(source: vf.Point | {
	    x: number;
	    y: number;
	}, PlusPoint: vf.Point | {
	    x: number;
	    y: number;
	}): {
	    x: number;
	    y: number;
	};
	/** 向量转弧度 */
	export function pointSignAngle(pointA: vf.Point | {
	    x: number;
	    y: number;
	}, pointB: vf.Point | {
	    x: number;
	    y: number;
	}): number;
	/**
	 *  根据类型获得具体的类定义
	 * @param type
	 */
	export function getGuiClass(type: string): any;
	export function sayHello(): void;
	/**
	 * 全局坐标转本地坐标
	 */
	export function toLocal(position: vf.IPoint, localDisplayObject: vf.DisplayObject | DisplayObjectAbstract): vf.Point;
	/**
	 * 本地坐标转全局坐标
	 */
	export function toGlobal(position: vf.IPoint, localDisplayObject: vf.DisplayObject | DisplayObjectAbstract): vf.Point;
	/**
	 * 本地坐标转全局
	 */
	export function toWorldTransform(localDisplayObject: vf.DisplayObject | DisplayObjectAbstract): vf.Matrix;
	export function toLoacalTransform(localDisplayObject: vf.DisplayObject | DisplayObjectAbstract): vf.Matrix;
	/**
	 * 本地显示对象转换到DIV坐标，核心是减去canvas的偏移量
	 * @param localDisplayObject
	 * @returns
	 */
	export function toDomRectangle(localDisplayObject: DisplayObjectAbstract | Stage, point?: vf.IPointData): vf.Rectangle;
	/**
	 * svgData to array
	 */
	export function path2shapes(path: string): never[][];
	/**
	 * array to svgData
	 */
	export function toSVGStr(shapes: any): any;
	export class ParseDataItem {
	    type: "M" | "L" | "Q" | "C";
	    x: number;
	    y: number;
	    ct1X: number;
	    ct1Y: number;
	    ct2X: number;
	    ct2Y: number;
	}
	/**
	 * 创建显示对象
	 * @param moduleName
	 * @param option
	 * @param parent
	 * example:
	 *   let img = vf.gui.Utils.createDisplayObject("Image", {x: 0, y: 0, src: 'xxxx.png'}, this) as vf.gui.Image;
	 */
	export function createDisplayObject(moduleName: string, option: any, parent?: DisplayObjectAbstract): any;

}
declare module 'src/core/Filter' {
	///   types="@vf.js/vf" />
	export class Filter extends vf.Filter {
	    static isFilter: boolean;
	    static defaultFilterVertex: string;
	    static list: Map<string, boolean>;
	    constructor(vertexSrc?: string, fragmentSrc?: string, uniforms?: {
	        [key: string]: any;
	    });
	}

}
declare module 'src/display/Slider' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { Image as VfuiImage } from 'src/display/Image';
	import { DragEvent, InteractionEvent } from 'src/interaction/Index';
	/**
	 * 滑动条/进度条
	 *
	 * @example let slider = new vf.gui.Slider();
	 *
	 */
	export class Slider extends DisplayObject {
	    constructor();
	    /**
	     * 当前值
	     */
	    protected _amt: number;
	    /**
	     * 小数的保留位，0不保留
	     * @default 0
	     */
	    protected _decimals: number;
	    protected _startValue: number;
	    protected _maxPosition: number;
	    protected _lastChange: number;
	    protected _lastChanging: number;
	    protected _localMousePosition: vf.Point;
	    /** 状态展示 */
	    readonly trackImg: VfuiImage;
	    readonly thumbImg: VfuiImage;
	    readonly tracklightImg: VfuiImage;
	    protected _thumbDrag: DragEvent;
	    protected _trackDrag: DragEvent;
	    /**
	     * 当前值
	     */
	    get value(): number;
	    set value(value: number);
	    protected valueSystem(value?: number): void;
	    /**
	     * 最小值
	     */
	    protected _minValue: number;
	    get minValue(): number;
	    set minValue(value: number);
	    /**
	     * 最大值
	     */
	    protected _maxValue: number;
	    get maxValue(): number;
	    set maxValue(value: number);
	    /**
	     * 是否垂直,滑块方向
	     */
	    protected _vertical: boolean;
	    get vertical(): boolean;
	    set vertical(value: boolean);
	    /**
	     * 背景
	     */
	    protected _track?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    get track(): string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined;
	    set track(value: string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined);
	    /**
	     * 手柄
	     */
	    protected _thumb?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    get thumb(): string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined;
	    set thumb(value: string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined);
	    /**
	     * 进度
	     */
	    protected _tracklight?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    get tracklight(): string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined;
	    set tracklight(value: string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined);
	    protected onImgload(): void;
	    protected updatePosition(soft?: boolean): void;
	    protected onPress(event: InteractionEvent, isPressed: boolean, dragEvent?: DragEvent): void;
	    protected onDragStart(event: InteractionEvent): void;
	    protected onDragMove(event: InteractionEvent, offset: vf.Point): void;
	    protected onDragEnd(event: InteractionEvent): void;
	    protected updatePositionToMouse(mousePosition: vf.Point, soft: boolean): void;
	    protected triggerValueChange(): void;
	    protected triggerValueChanging(): void;
	    updateLayout(): void;
	    protected commitProperties(): void;
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    release(): void;
	}

}
declare module 'src/display/ScrollBar' {
	///   types="@vf.js/vf" />
	import { Slider } from 'src/display/Slider';
	import { ScrollingContainer } from 'src/display/ScrollingContainer';
	import { Image } from 'src/display/Image';
	import { InteractionEvent } from 'src/interaction/Index';
	/**
	 * UI 带有滚动条的容器
	 */
	export class ScrollBar extends Slider {
	    constructor();
	    /**
	     * 是的自动隐藏滚动条
	     */
	    autohide: boolean;
	    private _scrollingContainer;
	    private _hidden;
	    protected toggleHidden(hidden: boolean): void;
	    protected onThumbLoadComplete(rectangle: vf.Rectangle, source: Image): void;
	    protected triggerValueChanging(): void;
	    private _source;
	    get source(): ScrollingContainer | string | undefined;
	    set source(value: ScrollingContainer | string | undefined);
	    private _dragScrolling;
	    get dragScrolling(): boolean;
	    set dragScrolling(value: boolean);
	    protected commitProperties(): void;
	    protected alignToContainer(): void;
	    protected onDragMove(event: InteractionEvent, offset: vf.Point): void;
	    protected updatePosition(soft?: boolean): void;
	    release(): void;
	}

}
declare module 'src/display/ScrollingContainer' {
	///   types="@vf.js/vf" />
	import { Container } from 'src/display/Container';
	import { ContainerBase } from 'src/core/ContainerBase';
	import { DisplayObjectAbstract } from 'src/core/DisplayObjectAbstract';
	/**
	 * 可滚动的容器
	 *
	 * @example let scrollingContainer = new vf.gui.ScrollingContainer();
	 *
	 */
	export class ScrollingContainer extends Container {
	    constructor();
	    /**
	     * 是否启动拖拽滚动
	     * @default true
	     */
	    private _dragScrolling;
	    get dragScrolling(): boolean;
	    set dragScrolling(value: boolean);
	    /**
	     * 滚动的阻力或柔度 (0-1)
	     * @default 0.5
	     */
	    softness: number;
	    /**
	     * 滚动条的圆角半径 设置0时，滚动条为直角长方形
	     * @default 0
	     */
	    radius: number;
	    private scrollMask;
	    /**
	     * 遮罩的扩充范围
	     */
	    expandMask: number;
	    /**
	     * 是否开启滚动动画
	     * @default false
	     */
	    animating: boolean;
	    /**
	     * 是否启用水平滚动
	     * @default false
	     */
	    scrollX: boolean;
	    /**
	     * 是否滚动中
	     */
	    scrollY: boolean;
	    /**
	     * 内容容器
	     * @private
	     */
	    private _innerContainer;
	    /**
	     * 内容的宽高
	     */
	    innerBounds: vf.Rectangle;
	    /**
	     * 拖动处理类
	     */
	    private dragEvent?;
	    /**
	     * 鼠标滚动
	     */
	    private mouseScrollEvent?;
	    /**
	     * 是否滚动中
	     */
	    private scrolling;
	    /**
	     * 临时方案，设置时间间隔，跳转容器宽高
	     */
	    private _boundCached;
	    private _lastWidth;
	    private _lastHeight;
	    private _isInitScrolling;
	    private _containerStart;
	    private _targetPosition;
	    private _lastPosition;
	    private _Position;
	    private _Speed;
	    private _stop;
	    private isInitDrag;
	    protected initDrag(): void;
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    protected setScrollPosition(speed?: vf.Point): void;
	    get innerContainer(): ContainerBase;
	    addChild<T extends DisplayObjectAbstract>(item: T): T;
	    addChildAt<T extends DisplayObjectAbstract>(item: T, index: number): T;
	    getInnerBounds(force?: boolean): vf.Rectangle;
	    $onInit(): void;
	    protected initScrolling(): void;
	    protected updateScrollBars(): void;
	    /**
	     * 百分比设置位置
	     * @param direction 方向
	     * @param pct 百分比0-1
	     */
	    forcePctPosition(direction: "x" | "y", pct: number): void;
	    /** 根据焦点设置位置 */
	    focusPosition(pos: vf.Point): void;
	    protected updateScrollPosition(delta: number): void;
	    protected updateDirection(direction: "x" | "y", delta: number): void;
	    release(): void;
	}

}
declare module 'src/display/SpriteAnimated' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 * 序列图动画
	 *
	 * 支持使用texturepacker导出以及处理轴点
	 *
	 * @example let spriteAnimated = new vf.gui.SpriteAnimated();
	 *
	 */
	export class SpriteAnimated extends DisplayObject {
	    constructor();
	    private _animatedSprites;
	    private _lastAnimatedName;
	    private _curFrameNumber;
	    private _setTimeoutId;
	    /**
	     * 要播放的动作名
	     */
	    private _animationName;
	    get animationName(): string;
	    set animationName(value: string);
	    /**
	     * 序列图路径，或序列图数组
	     */
	    private _src;
	    get src(): vf.Spritesheet | vf.Texture[] | vf.AnimatedSprite.FrameObject[] | undefined;
	    set src(value: vf.Spritesheet | vf.Texture[] | vf.AnimatedSprite.FrameObject[] | undefined);
	    /**
	     * 动画速度
	     */
	    private _animationSpeed;
	    get animationSpeed(): number;
	    set animationSpeed(value: number);
	    /**
	     * 是的循环
	     */
	    private _loop;
	    get loop(): boolean;
	    set loop(value: boolean);
	    private _playCount;
	    /**
	     * 循环次数
	     */
	    private _loopCount;
	    get loopCount(): number;
	    set loopCount(value: number);
	    /**
	     * 是否播放中
	     */
	    private _playing;
	    get playing(): boolean;
	    /**
	     * 锚点，调整位图的坐标中点 0-1, 可通过 TexturePacker输出sheet图并设置好 anchor
	     */
	    get anchorX(): number;
	    set anchorX(value: number);
	    /**
	     * 锚点，调整位图的坐标中点 0-1, 可通过 TexturePacker输出sheet图并设置好 anchor
	     */
	    get anchorY(): number;
	    set anchorY(value: number);
	    /** 跳转到第N帧并播放 */
	    gotoAndPlay(frameNumber: number): void;
	    /** 跳转到第N帧并停止 */
	    gotoAndStop(frameNumber: number): void;
	    /** 停止 */
	    stop(): void;
	    /** 播放 */
	    play(): void;
	    /**
	     * 请在构造函数后立即设置
	     */
	    get autoPlay(): boolean;
	    set autoPlay(value: boolean);
	    set isPlay(value: boolean);
	    /**
	     * 添加动画
	     */
	    addAnimated(animationName: string, textures: vf.Texture[] | vf.AnimatedSprite.FrameObject[]): void;
	    release(): void;
	    protected releaseAnimate(): void;
	    protected srcSystem(): void;
	    protected animatedNameSystem(): void;
	    protected playSystem(): void;
	    protected attribSystem(): void;
	}

}
declare module 'src/event/KeyEvent' {
	/**
	 * 键盘事件 驱动类KeysEvent
	 *
	 */
	export const enum KeyEvent {
	    input = "input",
	    /**
	     * 键盘按下
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    keydown = "keydown",
	    /**
	     * 键盘弹起
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    keyup = "keyup",
	    /**
	     * 粘贴
	     *
	     * (e:InteractionEvent,obj:DisplayObject,clipboardData: DataTransfer | null)
	     */
	    paste = "paste",
	    /**
	     * 复制
	     *
	     * (e:InteractionEvent,obj:DisplayObject,clipboardData: DataTransfer | null)
	     */
	    copy = "copy",
	    /**
	     * 剪切
	     *
	     * (e:InteractionEvent,obj:DisplayObject,clipboardData: DataTransfer | null)
	     */
	    cut = "cut",
	    /**
	     * 回退删除
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    backspace = 8,
	    /**
	     * 回车
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    enter = 13,
	    /**
	     * 删除
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    delete = 46,
	    /**
	     * 全选 ctrl+a
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    ctrlA = 65,
	    /**
	     * 撤销 ctrl+z
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    ctrlZ = 90,
	    /**
	     * 箭头左
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    left = 37,
	    /**
	     * 箭头上
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    top = 38,
	    /**
	     * 箭头右
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    right = 39,
	    /**
	     * 箭头下
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    down = 40,
	    /**
	     * shift + 箭头左
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    shiftLeft = "shift37",
	    /**
	     * shift + 箭头右
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    shiftRight = "shift39",
	    /**
	     * shift + 箭头上
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    shiftTop = "shift38",
	    /**
	     * shift + 箭头下
	     *
	     * (e:InteractionEvent,obj:DisplayObject)
	     */
	    shiftDown = "shift40"
	}

}
declare module 'src/display/private/HtmlInput' {
	///   types="@vf.js/vf" />
	/**
	 * 私有的，由于VFJS不支持文本输入，这里以HTML方式实现
	 */
	export default class HtmlInput extends vf.utils.EventEmitter {
	    constructor(multiline: boolean);
	    private _domInput;
	    private _selection;
	    private _restrictRegex;
	    private _restrictValue;
	    get domInput(): HTMLInputElement | HTMLTextAreaElement;
	    set visible(value: boolean);
	    get visible(): boolean;
	    get value(): string;
	    set value(value: string);
	    set placeholder(value: string);
	    set disabled(value: boolean);
	    get maxlength(): number;
	    set maxlength(value: number);
	    get restrict(): RegExp | undefined;
	    set restrict(regex: RegExp | undefined);
	    setStyle(style: InputStyle): void;
	    setStyleValue(key: any, value: any): void;
	    select(): void;
	    /** 测量，需要对象添加到body中 */
	    getDOMInputBounds(): DOMRect;
	    updatePostion(top: string | number, left: string | number, transform: string, opacity?: string | number): void;
	    private addDom;
	    private removeDom;
	    release(): void;
	    private _onInputKeyDownBind;
	    private _onInputInputBind;
	    private _onInputKeyUpBind;
	    private _onFocusedBind;
	    private _onBlurredBind;
	    private addEvent;
	    private removeEvent;
	    private _applyRestriction;
	    private _onInputKeyDown;
	    private _onInputInput;
	    private _onInputKeyUp;
	    private _onFocused;
	    private _onBlurred;
	    focus(): void;
	    blur(): void;
	}

}
declare module 'src/display/TextInput' {
	///   types="@vf.js/vf" />
	import HtmlInput from 'src/display/private/HtmlInput';
	import { InputBase } from 'src/display/private/InputBase';
	import { Image } from 'src/display/Image';
	/**
	 * 文本输入
	 *
	 * @example let textInput = new vf.gui.TextInput(true|false);//单行或多行
	 *
	 */
	export class TextInput extends InputBase {
	    constructor(multiline?: boolean);
	    protected _oldState: string;
	    protected htmlInputShared: HtmlInput;
	    protected _lastRenderer: vf.Renderer | undefined;
	    protected _resolution: number;
	    protected _canvasBounds: {
	        top: number;
	        left: number;
	        width: number;
	        height: number;
	    } | undefined;
	    protected _previous: {
	        canvasBounds: any;
	        worldTransform: any;
	        worldAlpha: any;
	        worldVisible: any;
	    } | any;
	    protected _inputStyle: InputStyle;
	    /**
	     * 预览文字的样式
	     */
	    protected placeholderColor: number;
	    protected _domVisible: boolean;
	    protected _textHitbox: vf.Graphics;
	    protected _textMask: vf.Graphics;
	    protected _text: vf.Text;
	    protected _fontMetrics: vf.IFontMetrics | undefined;
	    protected state: string;
	    /**
	     * 设置文本
	     */
	    get text(): string;
	    set text(value: string);
	    /**
	     * 预览文字
	     */
	    private _placeholder;
	    get placeholder(): string;
	    set placeholder(value: string);
	    /**
	     * 设置最大可输入
	     */
	    private _maxLength;
	    get maxLength(): number;
	    set maxLength(value: number);
	    /**
	     * 过滤表达式
	     */
	    private _restrict;
	    get restrict(): RegExp | undefined;
	    set restrict(value: RegExp | undefined);
	    /**
	     * 状态展示
	    */
	    readonly img: Image;
	    updateSystem(renderer?: vf.Renderer): void;
	    /**
	     * 设置焦点
	     */
	    focus(): void;
	    /**
	     * 失去焦点
	     */
	    blur(): void;
	    /**
	     * 设置css style样式
	     * @param key 健
	     * @param value 值
	     */
	    setInputStyle(key: any, value: any): void;
	    protected onStateChange(ui: TextInput, state: string): void;
	    private _onInputInput;
	    private _onFocused;
	    private _onBlurred;
	    private _setState;
	    private _updateSubstitution;
	    render(renderer: vf.Renderer): void;
	    private _renderInternal;
	    private _updateDOMInput;
	    private _needsUpdate;
	    private _updatetext;
	    private _ontextFocus;
	    private _ensureFocus;
	    private _derivetextStyle;
	    private _derivetextPadding;
	    private _derivetextText;
	    private _hasFocus;
	    private _getCanvasBounds;
	    private _getDOMRelativeWorldTransform;
	    private _vfMatrixToCSS;
	    private _comparevfMatrices;
	    private _compareClientRects;
	    release(): void;
	}

}
declare module 'src/display/Polygon' {
	import { GraphBase } from 'src/display/private/GraphBase';
	export class Polygon extends GraphBase {
	    constructor();
	    private path;
	    private PI_2;
	    private _triangleNum;
	    private RADIUS_V;
	    drawGraph(): void;
	    get triangleNum(): number;
	    set triangleNum(value: number);
	    private setStarPath;
	}

}
declare module 'src/display/Arrow' {
	import { GraphBase } from 'src/display/private/GraphBase';
	export class Arrow extends GraphBase {
	    constructor();
	    private _angle;
	    drawGraph(): void;
	    private getArrowPath;
	}

}
declare module 'src/display/Ellipse' {
	import { GraphBase } from 'src/display/private/GraphBase';
	/**
	 * 绘制椭圆
	 *
	 * 不设置 lineWidth 或 color 椭圆不可见
	 *
	 */
	export class Ellipse extends GraphBase {
	    constructor();
	    drawGraph(): void;
	}

}
declare module 'src/display/Isosceles' {
	import { GraphBase } from 'src/display/private/GraphBase';
	/**
	 * 等腰梯形和等腰三角形(上边长度为0)
	 *
	 * 梯形上边的中点为中心点
	 *
	 * 不设置 lineWidth 或 color 矩形不可见
	 *
	 */
	export class Isosceles extends GraphBase {
	    constructor();
	    private _upLine;
	    private _downLine;
	    private _path;
	    get upLine(): number;
	    set upLine(value: number);
	    get downLine(): number;
	    set downLine(value: number);
	    drawGraph(): void;
	    private setIsosPath;
	}

}
declare module 'src/display/Graphics' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { GraphicsCore } from 'src/display/private/GraphicsCore';
	/**
	 * 矢量绘制
	 *
	 * @example let graphics = new vf.gui.Graphics();
	 *
	 */
	export class Graphics extends DisplayObject {
	    constructor(geometry?: vf.GraphicsGeometry | undefined);
	    readonly graphics: GraphicsCore;
	}

}
declare module 'src/display/private/selectedBounds' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	export enum BoundsEventType {
	    boundsScale = "boundsScale",
	    boundsAngle = "boundsAngle",
	    selectedBoundsClicked = "selectedBoundsClicked"
	}
	export class SelectedBounds extends DisplayObject {
	    constructor();
	    private _boundsRect?;
	    private _selectedRect?;
	    private _lastPos;
	    private _bounds;
	    private _uiContainer?;
	    private _cornerContainer?;
	    private onMove;
	    /**
	     * 向量的夹角
	     */
	    private measureAngle;
	    /**
	     * 添加选中时的8个小方块
	     */
	    private addSelectedShapeRect;
	    private getBoundsPosList;
	    /**
	     * 显示
	     */
	    show(parent: DisplayObject, bounds: vf.Rectangle, scaleX?: number, scaleY?: number, angle?: number, showCorner?: boolean): void;
	    /**
	     * 更新
	     */
	    update(parent: DisplayObject, bounds: vf.Rectangle, scaleX?: number, scaleY?: number, angle?: number, showCorner?: boolean): void;
	    /**
	     * 隐藏
	     */
	    hide(): void;
	}

}
declare module 'src/display/FollowLine' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { InteractionEvent } from 'src/interaction/Index';
	import { FollowLineEnum } from 'src/enum/Index';
	/**
	 * 跟随鼠标或触摸绘制线条
	 *
	 * @example let graphics = new vf.gui.FollowLine();
	 *
	 */
	export class FollowLine extends DisplayObject {
	    constructor();
	    /** 线条 */
	    private _lines;
	    /** 触摸的ID */
	    private _touchId;
	    /** 位置缓存，记录画线时候每一个点，最后画完优化 */
	    private _posCache;
	    /** 保存已画线的key */
	    private _lineKeys;
	    /** 鼠标坐标 */
	    private _mouseOffset;
	    /** 上次点击坐标 */
	    private _lastPos;
	    /**
	     * 划线索引, 取时间戳
	     */
	    private _curLineIndex;
	    /**
	     * 需要处理的消息列表
	     */
	    private _messageCache;
	    /**
	     * 线条颜色
	     */
	    lineColor: number;
	    /**
	     * 线条宽度
	     */
	    lineWidth: number;
	    /**
	     * 是否暂停，一些特殊情况，如拖拽时，可暂停
	     */
	    isPause: boolean;
	    /**
	     * LINES instead of TRIANGLE_STRIP
	     */
	    private lineType;
	    /**
	     * 是否启用橡皮檫
	     */
	    isErasing: boolean;
	    /** 角色状态 */
	    role: FollowLineEnum.Role;
	    /** 选择框的容器  */
	    private _selectedBounds?;
	    /** 要删除的线，复制品 */
	    private _eraseLine?;
	    set eraseLine(value: vf.Graphics | undefined);
	    get eraseLine(): vf.Graphics | undefined;
	    /**
	     * @private
	     * 提交属性，子类在调用完invalidateProperties()方法后，应覆盖此方法以应用属性
	     */
	    protected commitProperties(): void;
	    /**
	     * 更新显示列表,子类重写，实现布局
	     */
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    /**
	     * 添加选择框
	     */
	    private addSelectedBound;
	    private onMessage;
	    private addEvent;
	    private removeEvent;
	    onPress(e: InteractionEvent, thisObj: DisplayObject, isPress: boolean): void;
	    onMove(e: InteractionEvent): void;
	    /**
	     * 发送操作事件
	     * @param operate   1添加 2删除 3重置
	     * @param role  Role
	     * @param lineIndex 线段 ID
	     */
	    private emitMsg;
	    /**
	     *
	     * @param name (name = role + lineId)
	     * @param role
	     */
	    private getGraphics;
	    private getCurLineByPos;
	    private getDataStrByPosCache;
	    private drawLine;
	    private removeLine;
	    clear(): void;
	    setData(data: string | string[]): void;
	    reset(): any;
	    release(): void;
	}

}
declare module 'src/display/ConnectLine' {
	import { DisplayObject } from 'src/core/DisplayObject'; type LinePostion = 'leftTop' | 'centerTop' | 'rightTop' | 'leftCenter' | 'center' | 'rightCenter' | 'leftBottom' | 'centerBottom' | 'rightBottom' | number[];
	export const play: unique symbol;
	/**
	 * 连线组件
	 *
	 *
	 * @example let connectLine = new vf.gui.ConnectLine();
	 *
	 */
	export class ConnectLine extends DisplayObject {
	    constructor();
	    private readonly line;
	    private _lastStartPos;
	    private _lastEndPos;
	    private _play;
	    private _tw?;
	    /**
	     *  触发画线操作
	     *
	     *  属性 play = 1 触发画线，线条从source->target.
	     *  属性 play = 2 触发画线，线条从target->source.
	     */
	    get play(): 2 | 1;
	    set play(value: 2 | 1);
	    private _autoPlay;
	    /**
	     *  默认 autoPlay = true
	     *
	     *  autoPlay = true时，组件在设置source,target,sourcePostion,targetPostion后自动触发画线，线条从source->target.
	     *
	     *  autoPlay = false时，设置source,target,sourcePostion,targetPostion后不会触发画线，需调用 play.
	     */
	    get autoPlay(): boolean;
	    set autoPlay(value: boolean);
	    private _source?;
	    /**
	     * 设置源显示对象
	     */
	    get source(): DisplayObject | undefined;
	    set source(value: DisplayObject | undefined);
	    private _sourcePostion;
	    /**
	     * 设置源显示对象位置
	     */
	    get sourcePostion(): LinePostion;
	    set sourcePostion(value: LinePostion);
	    private _target?;
	    /**
	     * 设置目标显示对象
	     */
	    get target(): DisplayObject | undefined;
	    set target(value: DisplayObject | undefined);
	    private _targetPostion;
	    /**
	     * 设置目标显示对象位置
	     */
	    get targetPostion(): LinePostion;
	    set targetPostion(value: LinePostion);
	    /**
	     * 线条颜色
	     */
	    private _lineColor;
	    get lineColor(): number;
	    set lineColor(value: number);
	    /**
	     * 线条粗细
	     */
	    private _lineWidth;
	    get lineWidth(): number;
	    set lineWidth(value: number);
	    private _isAnimation;
	    /**
	     * 线条位置改变时，是否有动画
	     */
	    get isAnimation(): boolean;
	    set isAnimation(value: boolean);
	    private _speed;
	    /**
	     * 设置获取连线速度
	     */
	    get speed(): number;
	    set speed(value: number);
	    protected commitProperties(): void;
	    private getLocalPos;
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    private animation;
	    set isClear(value: boolean);
	    clear(): void;
	    release(): void;
	}
	export {};

}
declare module 'src/display/Tracing' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { ClickEvent } from 'src/interaction/Index';
	import { TracingEnum } from 'src/enum/Index';
	export class Tracing extends DisplayObject {
	    constructor();
	    protected clickEvent: ClickEvent;
	    private _renderMode;
	    private _guideSprite;
	    private _bgSprite;
	    private _lines;
	    private _realTraceIndexArr;
	    private _tempTraceIndexArr;
	    private _lineStyle;
	    private _posCache;
	    private _drawing;
	    private _lastLocalPos;
	    private _curLocalPos;
	    private _autoComplete;
	    private _curIndex;
	    private _tracePointObjArr;
	    private _result;
	    private _groupStatusArr;
	    private _lineId;
	    private _newLineFlag;
	    private _pointId;
	    private _messageCache;
	    private _tween;
	    private _guideTime;
	    private _strictFlag;
	    private _fillIndex;
	    /**
	     * debug
	     */
	    private _debug;
	    get debug(): boolean;
	    set debug(value: boolean);
	    /**
	     * 模式
	     */
	    private _mode;
	    set mode(value: TracingEnum.Mode);
	    get mode(): TracingEnum.Mode;
	    /**
	     * 文字轨迹图
	     */
	    private _traceSprite;
	    get traceSprite(): string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined;
	    set traceSprite(value: string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined);
	    /**
	     * 背景图，mask模式用于画线后漏出来
	     */
	    private _renderBgSprite;
	    get renderBgSprite(): string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined;
	    set renderBgSprite(value: string | number | HTMLCanvasElement | vf.Texture | HTMLImageElement | HTMLVideoElement | undefined);
	    /**
	     * 轨迹点,二维数组
	     */
	    private _tracePoints;
	    get tracePoints(): {
	        x: number;
	        y: number;
	    }[][];
	    set tracePoints(value: {
	        x: number;
	        y: number;
	    }[][]);
	    /**
	     * 线宽
	     */
	    private _lineWidth;
	    get lineWidth(): number;
	    set lineWidth(value: number);
	    /**
	     * 颜色
	     */
	    private _lineColor;
	    get lineColor(): number;
	    set lineColor(value: number);
	    /**
	     * 检测精度
	     */
	    private _precision;
	    get precision(): number;
	    set precision(value: number);
	    /**
	     * 位图
	     */
	    private _lineTexture;
	    get lineTexture(): string | number | undefined;
	    set lineTexture(value: string | number | undefined);
	    /**
	     * 线透明度
	     */
	    private _lineOpacity;
	    get lineOpacity(): number | undefined;
	    set lineOpacity(value: number | undefined);
	    /**
	     * 画笔样式
	     */
	    private setLineStyle;
	    /**
	     * 轨迹图
	     */
	    private setTraceSprite;
	    /**
	     * mask背景图
	     */
	    private setRenderBgSprite;
	    /**
	     * 移出mask背景图
	     */
	    private removeRenderBgSprite;
	    /**
	     * 开始，适用于audo和teach模式
	     */
	    private start;
	    /**
	     * 教学引导
	     */
	    private guide;
	    private playGuideAnimal;
	    /**
	     * 清除教学引导
	     */
	    clearGuide(): void;
	    /**
	     * 自动绘制
	     */
	    private auto;
	    private _posLength;
	    private drawWithAnimation;
	    private autoNextPoint;
	    /**
	     * 更新显示列表,子类重写，实现布局
	     */
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	    $onInit(): void;
	    $onRelease(): void;
	    /**
	     * 检测触摸点和轨迹点
	     * @param point
	     */
	    private checkTrace;
	    /**
	     * 检查暂存区,抬起时检测暂存区中的点是否在一个笔画上
	     */
	    private checkTemp;
	    /**
	     * 检查group
	     */
	    private checkResult;
	    private checkStrictFirstPoint;
	    private checkStrict;
	    private checkFill;
	    /**
	     * 教学模式检查
	     */
	    private checkTeach;
	    /**
	     * 画线
	     * @param lineId
	     * @param data
	     * @param from
	     * @param to
	     * @param lineStyle
	     */
	    private drawLine;
	    /**
	     * 绘图
	     * @param graphics
	     * @param posList
	     */
	    private draw;
	    /**
	     * 本地绘制
	     * @param graphics
	     */
	    private localDraw;
	    private onPress;
	    private onMove;
	    /**
	     *
	     * @param lineId
	     * @param lineStyle
	     */
	    private getGraphics;
	    private getDataStrByPosCache;
	    /**
	     * 发送一个笔画的msg
	     * @param lineId
	     * @param data
	     */
	    private emitTracingMsg;
	    private onMessage;
	    removeLine(lineId: string): void;
	    /**
	     * clear
	     */
	    clear(): void;
	    /**
	     * @private
	     * 提交属性，子类在调用完invalidateProperties()方法后，应覆盖此方法以应用属性
	     */
	    protected commitProperties(): void;
	    setData(data: string | string[]): void;
	    set source(data: string | string[]);
	}

}
declare module 'src/display/animation/Timeline' {
	export class Timeline<T> {
	    set defaultValue(value: T);
	    get curValue(): T;
	    set globalTime(v: number);
	    frames: Array<Frame<T>>;
	    private curTime;
	    lastTime: number;
	    loop: boolean;
	    totalTime: number;
	    protected _defaultValue: T;
	    protected _globalTime: number;
	    protected _lastGlobalTime: number;
	    protected _lastFrame: Frame<T> | null;
	    protected _curFrame: Frame<T> | null;
	    protected _nextFrame: Frame<T>;
	    protected _times: number;
	    protected _curValue: T;
	    constructor();
	    protected getProgress(cur: number, min: number, max: number, ease: ((k: number) => number) | any): number;
	    protected tick(): void;
	    protected updateCurFrame(): void;
	    protected updateCurValue(): void;
	    release(): void;
	}
	export class Frame<T> {
	    time: number;
	    ease?: ((k: number) => number) | any;
	    value: T;
	    getValue(progress: number, value: T): T;
	}
	export class NumberFrame extends Frame<number> {
	    constructor();
	    getValue(progress: number, value: number): number;
	}

}
declare module 'src/display/animation/PathTimeline' {
	import { Timeline } from 'src/display/animation/Timeline';
	export class PathTimeline extends Timeline<number> {
	    private path;
	    private length;
	    constructor(path: string);
	    get curPos(): [number, number];
	    get angle(): number;
	    release(): void;
	}

}
declare module 'src/display/animation/AnimationPath' {
	import { AnimationBase } from 'src/display/private/AnimationBase';
	export class AnimationPath extends AnimationBase {
	    private pathTimeline?;
	    constructor(sp?: any, options?: any, duratime?: number);
	    play(timer?: number): void;
	    gotoAndStop(timer: number): void;
	    protected updata(delta: number): void;
	    release(): void;
	}

}
declare module 'src/display/animation/Animation' {
	export class Animation {
	    private static _aniList;
	    static play(type: string, sprite: any, options: any, durtime?: number, callBack?: Function): any;
	    private static removeItem;
	    static releaseAll(): void;
	}

}
declare module 'src/display/private/AnimationBase' {
	///   types="@vf.js/vf" />
	export class AnimationBaseData {
	    x: number;
	    y: number;
	    rotation: number;
	}
	export class AnimationBase extends vf.utils.EventEmitter {
	    private _sprite;
	    protected _spriteData?: AnimationBaseData;
	    private _options;
	    private _duratime;
	    protected _currenTimer: number;
	    protected _revertAni: boolean;
	    private _playing;
	    private _valuesStart;
	    protected _toValue: any;
	    private _addTick;
	    constructor(sp?: any, options?: any, duratime?: number);
	    get playing(): boolean;
	    get sprite(): any;
	    set sprite(value: any);
	    get options(): any;
	    set options(value: any);
	    get revertAni(): boolean;
	    protected cacheSprite(): void;
	    play(curTimer?: number): void;
	    pause(): void;
	    /**
	     * 播放完成
	     */
	    complete(): void;
	    gotoAndPlay(timer: number): void;
	    gotoAndStop(timer: number): void;
	    /**
	     * 跳转
	     */
	    goto(timer: number): void;
	    /**
	     *
	     * 设置当前sprite状态
	     */
	    private setTimeStates;
	    /**
	     * 获取当前时间的sprite数据
	     * 如果重播时重头播放就可以  子类可以不用重写
	     *  每个动画计算方式不同 这个方法需要重写
	     */
	    getTimeData(timer: number): AnimationBaseData | undefined;
	    /**
	     *
	     */
	    protected updata(delta: number): void;
	    release(): void;
	}

}
declare module 'src/display/animation/AnimationJitter' {
	import { AnimationBase } from 'src/display/private/AnimationBase';
	export class AnimationJitter extends AnimationBase {
	    private tween;
	    constructor(sp?: any, options?: any, duratime?: number);
	    play(timer?: number): void;
	    gotoAndStop(timer: number): void;
	    private clearTween;
	    complete(): void;
	    release(): void;
	}

}
declare module 'src/interaction/AudioGroupController' {
	import { Audio } from 'src/display/Audio';
	interface AudioGroupObject {
	    groups: {
	        [key: string]: {
	            [value: string]: Audio;
	        };
	    };
	    values: {
	        [key: string]: string | undefined;
	    };
	}
	export const _audioGroupObject: AudioGroupObject;
	export function registrerAudioGroup(cb: Audio): void;
	/**
	 * 注销指定分组或指定分组的子项
	 * @param cb video
	 */
	export function unRegistrerAudioGroup(cb: Audio): void;
	/** 更新分组中选中的checkbox组件  */
	export function updateAudioGroupStates(cb: Audio): void;
	export {};

}
declare module 'src/display/Audio' {
	import { DisplayObject } from 'src/core/DisplayObject';
	/**
	 * 音频组件
	 *
	 * 准备完成 canplaythrough
	 *
	 * 播放事件 play
	 *
	 * 暂停事件 pause
	 *
	 * 错误事件 error
	 *
	 * 播放时间改变 timeupdate
	 *
	 * 播放完成 ended
	 *
	 * @example let audio = new vf.gui.Audio();
	 *
	 *
	 */
	export enum PlayerStates {
	    init = "init",
	    play = "play",
	    pause = "pause",
	    end = "end"
	}
	export class Audio extends DisplayObject {
	    private audio?;
	    private _id;
	    private _src;
	    private _autoplay;
	    private _loop;
	    private _playbackRate;
	    private _volume;
	    private _audioUid;
	    private _playerStates;
	    private stoping;
	    constructor();
	    set audioUid(value: string);
	    private initAudio;
	    /**
	    * 设置src 支持3种 url base64 arraybuffer;
	    */
	    set src(value: any);
	    get src(): any;
	    set autoplay(value: boolean);
	    get autoplay(): boolean;
	    set loop(value: boolean);
	    get loop(): boolean;
	    set playbackRate(value: number);
	    get playbackRate(): number;
	    set volume(value: number);
	    get volume(): number;
	    get duration(): number;
	    get paused(): boolean;
	    /**
	    * 设置分组名
	    */
	    get audioGroup(): string | undefined;
	    set audioGroup(value: string | undefined);
	    get playerStates(): PlayerStates;
	    get isPlaying(): boolean;
	    /**
	    * 支持的方法们~~~··~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	    *    */
	    /**
	     * 声音播放接口
	     *
	     *  await sound.play()
	     * @param {number} [time] - 声音延迟开始
	     * @param {number} [offset] - 声音的开始偏移值
	     * @param {number} [length] - 声音持续时间（以秒为单位）
	     */
	    play(time?: number, offset?: number, length?: number): void;
	    /**
	    * 停止声音
	    * @param time (optional) X秒后停止声音。默认情况下立即停止
	    */
	    stop(time?: number): void;
	    /**
	    * 暂停声音
	    */
	    pause(): void;
	    /**
	    * 释放
	    */
	    dispose(): void;
	    release(): void;
	    /**
	    * 各种可取参数.~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	    */
	    protected commitProperties(): void;
	    private useNativeAudio;
	    private nativeEmit;
	}

}
declare module 'src/event/SchedulerEvent' {
	export const enum SchedulerEvent {
	    /**
	     * 心跳
	     */
	    TICK = "tick",
	    /**
	     * 启动/开始
	     */
	    START = "start",
	    /**
	     * 更新
	     */
	    UPDATE = "update",
	    /**
	     * 结束
	     */
	    END = "end"
	}

}
declare module 'src/event/Index' {
	import * as ComponentEvent from 'src/event/ComponentEvent';
	import { InteractionEvent } from 'src/event/InteractionEvent';
	import { TouchMouseEvent } from 'src/event/TouchMouseEvent';
	import { TweenEvent } from 'src/event/TweenEvent';
	import { SchedulerEvent } from 'src/event/SchedulerEvent';
	export { ComponentEvent, InteractionEvent, TouchMouseEvent, TweenEvent, SchedulerEvent };

}
declare module 'src/display/PathGraphics' {
	import { GraphBase } from 'src/display/private/GraphBase';
	export enum ArrowType {
	    None = 0,
	    HollowCircle = 1,
	    FullCircle = 2,
	    HollowRect = 3,
	    FullRect = 4,
	    HollowArrow = 5,
	    FullArrow = 6,
	    line = 7
	}
	/**
	 * 矢量绘制
	 *
	 * @example let graphics = new vf.gui.Graphics();
	 *
	 */
	export class PathGraphics extends GraphBase {
	    constructor();
	    private _path;
	    private _pathData;
	    private _beginPort;
	    private _endPort;
	    private _graphicsBegin;
	    private _graphicsEnd;
	    private _beginRotation;
	    private _endRotation;
	    private _isSvgPath;
	    get path(): string;
	    set path(value: string);
	    get beginPort(): ArrowType;
	    set beginPort(value: ArrowType);
	    get endPort(): ArrowType;
	    set endPort(value: ArrowType);
	    drawGraph(): void;
	    private getType;
	    /**
	     * 新的解析方式
	     */
	    private drawInfoData;
	    private drawBeginPort;
	    private drawEndPort;
	    private drawShape;
	    /**
	  * svg格式线条 解析
	  *
	  * M 表示MoveTo
	   *   L 表示LineTo，
	   *   Q表示二次贝塞尔曲线
	   *   C 表示三次贝塞尔曲线
	  */
	    release(): void;
	}

}
declare module 'src/display/Alert' {
	///   types="@vf.js/vf" />
	import { DisplayObject } from 'src/core/DisplayObject';
	import { DisplayLayoutAbstract } from 'src/core/DisplayLayoutAbstract';
	export interface ButtonInfo {
	    btnNormal?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    btnHover?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    btnPressed?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    text?: string;
	}
	export class Alert extends DisplayObject {
	    static show(container: DisplayLayoutAbstract, content: string, textAlign?: string, duration?: number, icon?: number | string | vf.Texture, title?: string, buttons?: string[], x?: number, y?: number): Alert;
	    constructor();
	    /**
	     * 弹框标题
	     */
	    private _title;
	    set title(value: string);
	    get title(): string;
	    /**
	     * 弹框内容
	     */
	    private _content;
	    set content(value: string);
	    get content(): string;
	    /**
	     * 按钮内容
	     */
	    private _buttons;
	    set buttons(value: string[]);
	    get buttons(): string[];
	    private _imgButtons;
	    set imgButtons(value: ButtonInfo[]);
	    get imgButtons(): ButtonInfo[];
	    /**
	     * 自动弹出
	     */
	    autoShow: boolean;
	    /**
	     * 自动释放
	     */
	    autoRelease: boolean;
	    /**
	     * 持续时间
	     */
	    duration: number;
	    /**
	     * 内容对齐方式  //left  center
	     */
	    textAlign: string;
	    /**
	     * 按钮默认宽高
	     */
	    buttonWidth: number;
	    buttonHeight: number;
	    /**
	     * 背景遮罩颜色透明度
	     */
	    maskColor: number;
	    maskOpacity: number;
	    /**
	     * 皮肤样式
	     */
	    icon?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    background?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    btnNormal?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    btnHover?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    btnPressed?: string | number | vf.Texture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
	    backgroundColor: number;
	    titleColor: number;
	    contentColor: number;
	    btnColors: number[];
	    btnTextColors: number[];
	    /**
	     * 显示状态
	     */
	    private _isShowing;
	    /**
	     * 组件显示对象
	     */
	    private _bgDisplay?;
	    private _titleDisplay?;
	    private _lineDisplay?;
	    private _contentDisplay?;
	    private _iconDisplay?;
	    private _buttonsDisplays;
	    protected commitProperties(): void;
	    /**
	     * 初始化显示
	     */
	    private initDisplay;
	    private _updateDisplayList;
	    /**
	     * 显示弹出框
	     */
	    show(): void;
	    /**
	     * 关闭弹出框
	     */
	    close(): void;
	    /**
	     * 释放
	     */
	    release(): void;
	    private onHover;
	    private onPress;
	    private onClick;
	}

}
declare module 'src/display/AutoContainer' {
	import { DisplayObjectAbstract } from 'src/core/DisplayObjectAbstract';
	import { Scheduler } from 'src/core/Scheduler';
	import { TimeLine } from 'src/tween/TimeLine';
	import { Tween } from 'src/tween/Tween';
	import { Container } from 'src/display/Container';
	/**
	 * 自动容器，提供各种组件的构造接口， timeline、tween、schedule的自动释放
	 * 手写代码构建scene的最佳实践：
	 * class Scene extends vf.gui.AutoContainer{
	 *
	 * }
	 */
	export class AutoContainer extends Container {
	    constructor();
	    private idCountDict;
	    private timeLineList;
	    private tweenList;
	    private schedulerList;
	    createDisplayObject(moduleName: string, option: any, parent?: DisplayObjectAbstract): any;
	    createTimeLine(option: any): TimeLine;
	    createTween(object: any): Tween;
	    setTimeout(time: number, callFunc: (data?: any) => void): Scheduler;
	    setInterval(time: number, callFunc: (data?: any) => void): Scheduler;
	    setEnterFrame(callFunc: (data?: any) => void): Scheduler;
	    release(): void;
	}

}
declare module 'src/UI' {
	///   types="@vf.js/vf" />
	/** 工具类 */
	import * as Utils from 'src/utils/Utils';
	/** UI舞台，最顶级的层 展示所有UI组件 */
	import { Stage } from 'src/core/Stage';
	/** UI基础显示对象，一般不会直接使用，只作为类型推断 */
	import { DisplayObject } from 'src/core/DisplayObject';
	/** 心跳，需要在初始化完成后，启动心跳更新 */
	import { TickerShared } from 'src/core/Ticker';
	/** 滤镜的基础类 */
	import { Filter } from 'src/core/Filter';
	/**
	 * 基础容器
	 *
	 * 设置checkGroup后，进行分组。 分组后，可理解为复选框。
	 *
	 * @example let container = new vf.gui.Container();
	 *
	 */
	import { Container } from 'src/display/Container';
	/**
	 * 滚动容器
	 *
	 * @example let scrollingContainer = new vf.gui.ScrollingContainer();
	 *
	 */
	import { ScrollingContainer } from 'src/display/ScrollingContainer';
	/**
	 * 图片
	 *
	 * @example let image = new vf.gui.Image();
	 *
	 *
	 */
	import { Image } from 'src/display/Image';
	/**
	 * 序列图动画
	 *
	 * 支持使用texturepacker导出以及处理轴点
	 *
	 * @example let spriteAnimated = new vf.gui.SpriteAnimated();
	 *
	 */
	import { SpriteAnimated } from 'src/display/SpriteAnimated';
	/**
	 * 文本
	 *
	 * 中文换行特殊处理 xxxx.style.breakWords = true;
	 *
	 * 文本没有宽高，自适应
	 *
	 * @example let label = new vf.gui.Label();
	 *
	 *
	 */
	import { Label } from 'src/display/Label';
	/**
	 * 文本输入
	 *
	 * @example let textInput = new vf.gui.TextInput(true|false);//单行或多行
	 *
	 *
	 */
	import { TextInput } from 'src/display/TextInput';
	/**
	 * 滑动条/进度条
	 *
	 * @example let slider = new vf.gui.Slider();
	 *
	 */
	import { Slider } from 'src/display/Slider';
	/**
	 * 按钮
	 *
	 * @example let button = new vf.gui.Button();
	 *
	 */
	import { Button } from 'src/display/Button';
	/**
	 * 单选\复选框
	 *
	 * 设置checkGroup后，进行分组。 分组后，可理解为复选框。
	 *
	 * @example let checkBox = new vf.gui.CheckBox();
	 *
	 *
	 */
	import { CheckBox } from 'src/display/CheckBox';
	/**
	 * 绘制矩形或圆角矩形
	 *
	 * @example let rect = new vf.gui.Rect();
	 *
	 *
	 */
	import { Rect } from 'src/display/Rect';
	/**
	 * 绘制矩形或圆角矩形
	 *
	 * @example let rect = new vf.gui.Circle();
	 *
	 *
	 */
	import { Circle } from 'src/display/Circle';
	/**
	 * 星型绘制
	 *
	 */
	import { Star } from 'src/display/Star';
	/**
	 * 多边形绘制
	 *
	 */
	import { Polygon } from 'src/display/Polygon';
	/**
	 * 箭头绘制
	 *
	 */
	import { Arrow } from 'src/display/Arrow';
	/**
	 * 椭圆绘制
	 *
	 */
	import { Ellipse } from 'src/display/Ellipse';
	/**
	 * 等腰绘制
	 *
	 */
	import { Isosceles } from 'src/display/Isosceles';
	/**
	 * 矢量绘制
	 *
	 * @example let graphics = new vf.gui.Graphics();
	 *
	 *
	 */
	import { Graphics } from 'src/display/Graphics';
	/**
	 * 跟随划线（鼠标或触摸按下时）
	 *
	 * @example let graphics = new vf.gui.FollowLine();
	 *
	 *
	 */
	import { FollowLine } from 'src/display/FollowLine';
	import { Video } from 'src/display/Video';
	/**
	 * 连线组件
	 *
	 *
	 * @example let connectLine = new vf.gui.ConnectLine();
	 *
	 *
	 */
	import { ConnectLine } from 'src/display/ConnectLine';
	/**
	 * 临摹组件
	 *
	 * @example let Tracing = new vf.gui.Tracing();
	 *
	 */
	import { Tracing } from 'src/display/Tracing';
	/**
	 * 滚动组件
	 *
	 * @example let scrollBar = new vf.gui.ScrollBar();
	 *
	 *
	 */
	import { ScrollBar } from 'src/display/ScrollBar';
	/**
	 * 完整的缓动曲线列表
	 *
	 * @example vf.gui.Easing.Linear.None;
	 *
	 *
	 */
	import { Easing } from 'src/tween/Easing';
	/**
	 * 缓动动画
	 *
	 * @example let tween = new vf.gui.Tween(myObject).to({width:'300px'}, 2000).start()
	 *
	 *
	 */
	import { Tween } from 'src/tween/Tween';
	/**
	 * 动画时间轴
	 */
	/**
	 * 振动动画
	 */
	import { AnimationJitter } from 'src/display/animation/AnimationJitter';
	import { Animation } from 'src/display/animation/Animation';
	import { NumberFrame } from 'src/display/animation/Timeline';
	/**
	 * 基于帧的时间轴控制类
	 *
	 * @example let timeline = new vf.gui.Timeline();
	 *
	 *
	 */
	import { TimeLine } from 'src/tween/TimeLine';
	/**
	 * 音频
	 *
	 *
	 *
	 * 估计是能播放  没毛病
	 *
	 * @example let audio = new vf.gui.Audio(“地址或者是arrbuffer”);
	 *
	 *
	 */
	import { Audio } from 'src/display/Audio';
	/**
	 * 事件绑定类，非继承于inputbase的组件是没有任何交互事件，需单独绑定
	 */
	import * as Interaction from 'src/interaction/Index';
	/**
	 * 事件名
	 */
	import * as Event from 'src/event/Index';
	/**
	 * 枚举
	 */
	import * as Enum from 'src/enum/Index';
	import { Scheduler } from 'src/core/Scheduler';
	import { SyncManager } from 'src/interaction/SyncManager';
	/**
	 *  路线绘制
	 */
	import { PathGraphics } from 'src/display/PathGraphics';
	import { Alert } from 'src/display/Alert';
	/**
	 * 自动容器
	 */
	import { AutoContainer } from 'src/display/AutoContainer';
	export type Application = vf.Application;
	/** 请不要在编写UI组件内部使用本类 */
	export { Audio, Filter, Utils, Stage, Container, AutoContainer, ScrollingContainer, Slider, Label, TextInput, Button, Video, CheckBox, Rect, Circle, Star, Arrow, Ellipse, Isosceles, Graphics, FollowLine, Tracing, ConnectLine, ScrollBar, Polygon, Interaction, DisplayObject, TickerShared, Tween, TimeLine, Easing, Image, SpriteAnimated, Event, Enum, Scheduler, NumberFrame, PathGraphics, AnimationJitter, Animation, SyncManager, Alert, };

}
declare module 'src/vf-gui' {
	import * as gui from 'src/UI';
	export { gui };

}
declare interface ObjectConstructor {
    assign(...objects: Record<string, any>[]): Record<string, any>;
}
interface ArrayConstructor {
    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
    from<T>(arrayLike: ArrayLike<T>): T[];
}
interface String {
    startsWith(searchString: string, position?: number): boolean;
}
interface TInputBase {
    blur?: Function;
    focus?: Function;
}
interface InputStyle {
    [propName: string]: any;
    fontFamily: string;
    fontSize?: string;
    fontWeight?: string;
    fontVariant: "normal" | "small-caps" | "inherit";
    color: '#000000';
    padding: string;
    multiline: boolean;
    fontStyle: "normal" | "italic" | "oblique" | "inherit";
    letterSpacing: number;
    textIndent: string;
    position: 'absolute';
    background: 'none';
    border: 'none';
    outline: 'none';
    transformOrigin: '0 0';
    lineHeight: '1';
}
interface Lifecycle {
    /**
     * 组件加载，暂时可能用不到
     */
    load(): void;
    /**
     * 释放，回收
     */
    release(): void;
}
/**
 * 生命周期的接口
 */
interface LifecycleHook {
    /**
     * 显示对象初始化完成，只执行一次,子类重写，不可外部调用
     */
    $onInit(): void;
    /**
     * 加载完成，不可外部调用
     */
    $onLoad(): void;
    /**
     * 回收，释放完成，不可外部调用
     */
    $onRelease(): void;
    /**
     * 添加到舞台后，不可外部调用
     */
    $onAddStage(): void;
    /**
     * 移出舞台后，不可外部调用
     */
    $onRemoveStage(): void;
}
declare module 'src/core/UIBase' {
	import { DisplayObject } from 'src/core/DisplayObject';
	export class UIBase extends DisplayObject implements Lifecycle {
	    constructor();
	}

}
declare module 'src/display/Pasition' {
	export class PasitionOptions {
	    from: any;
	    to: any;
	    duration: number;
	    mustSvgData?: boolean | undefined;
	    easing?: ((k: number) => number) | any;
	    onStart?: Function;
	    onUpdate?: Function;
	    onEnd?: Function;
	}
	export class Pasition {
	    private MIM_CURVES_COUNT;
	    private _beginTime;
	    private _pathArr;
	    private _pathB;
	    private _options?;
	    constructor(option?: PasitionOptions);
	    get from(): any;
	    set from(value: any);
	    get to(): any;
	    set to(value: any);
	    get duration(): number;
	    set duration(value: number);
	    get onStart(): Function | undefined;
	    set onStart(value: Function | undefined);
	    get onUpdate(): Function | undefined;
	    set onUpdate(value: Function | undefined);
	    get onEnd(): Function | undefined;
	    set onEnd(value: Function | undefined);
	    get easing(): any;
	    set easing(value: any);
	    get options(): PasitionOptions;
	    /**
	     * 动画初始值
	     */
	    play(): void;
	    /**
	     * 刷新
	     */
	    private onUpdata;
	    private _lerp;
	    private lerpCurve;
	    private lerpPoints;
	    /**
	     * 保持线条长度和关键点数相同
	     */
	    private _preprocessing;
	    private _splitCurves;
	    private split;
	    private _split;
	    private sync;
	    /**
	     * 取移动点最短距离的方案
	     */
	    private sort;
	    private boxDistance;
	    private sortCurves;
	    private permuteCurveNum;
	    private curveDistance;
	    private shapeBox;
	    private permuteNum;
	    private permute;
	    release(): void;
	}

}
declare module 'src/enum/ComponentEvent' {
	/**
	 * 特定属性改变时,通常为了去系统事件区分，UI组件的事件名为大写
	 * 1. CheckBox 的 checked 改变时
	 * 2. Label 的 text 改变时
	 * 3. SpriteAnimated 的 animationName 改变时
	 * 4. Button 文字改变
	 * 5. ScrollingContainer 拖动改变时
	 * 6. Slider 滑动改变后
	 * 7. SpriteAnimated 动画改变后
	 * 8. ConnectLine 连线完成时
	 * 9. Tracing 临摹完成一个笔画
	 */
	export const CHANGE = "CHANGE";
	/**
	 * 状态改变中
	 *
	 * slider 滑动时
	 */
	export const CHANGEING = "CHANGEING";
	/**
	 * 状态切换完成时
	 *
	 * 1. SpriteAnimated 每次播放完时，触发(loop = false时)
	 * 2. Image 图片加载完成时
	 * 3. Slider 滑动完成
	 * 4. Timeline  每次播放完时，触发(loop = false时)
	 * 5. FollowLine 完成一次划线
	 * 6. Tracing 临摹全部完成
	 */
	export const COMPLETE = "COMPLETE";
	/**
	 * 状态发生改变时
	 */
	export const STATE_CHANGE = "STATE_CHANGE";
	/**
	 * 状态切换完成时
	 *
	 * SpriteAnimated 每次播放完时，，触发(loop = true时)
	 */
	export const LOOP = "LOOP";
	/**
	 * 组件被添加前
	 */
	export const ADD = "add";
	/**
	 * 组件被添加时
	 */
	export const ADDED = "added";
	/**
	 * 组件被移除时
	 */
	export const REMOVEED = "removed";
	/**
	 * 组件大小改变后
	 */
	export const RESIZE = "RESIZE";
	/**
	 * 组件位置移动
	 */
	export const MOVE = "MOVE";
	/**
	 * 组件创建完成后
	 */
	export const CREATION_COMPLETE = "CREATION_COMPLETE";
	/**
	 * 组件拖动开始之前
	 */
	export const DRAG_START_BEFORE = "DRAG_START_BEFORE";
	/**
	 * 组件拖动开始时
	 */
	export const DRAG_START = "DRAG_START";
	/**
	 * 组件拖动结束之前
	 */
	export const DRAG_END_BEFORE = "DRAG_END_BEFORE";
	/**
	 * 组件拖动结束时 （如果绑定接收容器并拖动到接收容器中，不会触发此事件）
	 */
	export const DRAG_END = "DRAG_END";
	/**
	 * 组件拖动中
	 */
	export const DRAG_MOVE = "DRAG_MOVE";
	/**
	 * 组件拖动到接收目标中之前
	 */
	export const DRAG_TARGET_BEFORE = "DRAG_TARGET_BEFORE";
	/**
	 * 组件拖动到接收目标中
	 */
	export const DRAG_TARGET = "DRAG_TARGET";
	/**
	 * 有拖拽物掉落到此容器时触发
	 */
	export const DROP_TARGET = "DROP_TARGET";
	/**
	 * 播放音效 {name,mode}
	 */
	export const PLAY_AUDIO = "PLAY_AUDIO";

}
declare module 'src/interaction/KeyboardEvent' {
	import { DisplayObject } from 'src/core/DisplayObject'; class KeyboardSelectEvent {
	    /**
	     * document的键盘事件
	    */
	    constructor();
	    private obj;
	    private ctrlDown;
	    private shiftDown;
	    private shiftKey;
	    private ctrlKey;
	    private cmdKey;
	    private isAddEvent;
	    private keyDownEventBind;
	    private keyUpEventBind;
	    private pasteEventBind;
	    private copyEventBind;
	    private cutEventBind;
	    private addEvent;
	    private removeEvent;
	    protected keyDownEvent(e: KeyboardEvent): void;
	    protected keyUpEvent(e: KeyboardEvent): void;
	    protected copyEvent(e: ClipboardEvent): void;
	    protected cutEvent(e: ClipboardEvent): void;
	    protected pasteEvent(e: ClipboardEvent): void;
	    focus(obj: DisplayObject): void;
	    blur(): void;
	}
	/**
	 * KeyboardSelectEvent 的实例
	 */
	export const keyboardShared: KeyboardSelectEvent;
	export {};

}
declare module 'src/tween/private/PlaybackPosition' {
	/**
	 * 回放位置的相关操作函数
	 */
	export default class PlaybackPosition {
	    constructor();
	    private totalTime;
	    private labels;
	    private offsets;
	    parseLabel(_name: string, offset: string | number | null): number;
	    addLabel(_name: string, offset: string | number | null): this;
	    setLabel(_name: string, offset: string | number | null): this;
	    eraseLabel(_name: string, offset: string | number | null): this;
	}

}
declare module 'test/TestAlert' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestAlert {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    onLoad(app: vf.Application, uiStage: vf.gui.Stage): void;
	    alertClicked(target: any, index: number): void;
	}

}
declare module 'test/TestAlign' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestAlign {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	}

}
declare module 'test/TestAnimationJitter' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestAnimationJitter {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    private callBack;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestApplication' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestApplication {
	    constructor(thisObj: any, callback: (app: vf.Application, uiStage: vf.gui.Stage) => void);
	}

}
declare module 'test/TestArrow' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestArrow {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _arrow?;
	    private _buttonList;
	    private onLoad;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestAudio' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestAudio {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestAutoContainer' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestAutoContainer {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    onLoad(app: vf.Application, uiStage: vf.gui.Stage): void;
	}

}
declare module 'test/TestButton' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestButton {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _TestButton?;
	    private _buttonList;
	    private onLoad;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestCamera' {
	///   types="@vf.js/vf" />
	export default class TestCamera {
	    private sss;
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    video: any;
	    sprite: vf.Sprite;
	    private stream;
	    private errorFunc;
	    private openMedia;
	    private closeMedia;
	    /**
	     * 初始化完成后，外部触发调用
	     */
	    onLoad(): void;
	    /**
	     * 卸载
	     */
	    release(): void;
	    /**
	     * 更新显示
	     * @param unscaledWidth
	     * @param unscaledHeight
	     */
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	}

}
declare module 'test/TestCheckBox' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestCheckBox {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _TestCheckBox?;
	    private onLoad;
	    private getNewCheckBox;
	    private getNewRadio;
	    private onChange;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestCircle' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestCircle {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _circle?;
	    private _circle1?;
	    private _circle2?;
	    private _buttonList;
	    private onLoad;
	    private onClick;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestConnectLine' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestConnectLine {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _connectLine1?;
	    private _connectLine2?;
	    private _connectLine3?;
	    private _container?;
	    private _rect1?;
	    private _rect2?;
	    private _e4Rect1?;
	    private _e4Rect2?;
	    private _e4Line1?;
	    private _buttonList;
	    private _timeOutId;
	    private onLoad;
	    private getNewRect;
	    private getNewConnectLine;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestContainer' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestContainer {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _container1?;
	    private _container2?;
	    private _container3?;
	    private _container4?;
	    private _container5?;
	    private _container6?;
	    private _containerTop?;
	    private _containerLeft?;
	    private _containerRight?;
	    private _containerBottom?;
	    private _buttonList;
	    private onLoad;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestDrag' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestDrag {
	    private id;
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    private getNewContainer;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestEllipse' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestCircle {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestFillColor' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestRect {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _buttonList;
	    private onLoad;
	    private allG;
	    private getRandomRGBA;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestFollowLine' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestFollowLine {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _eraseBtn?;
	    private _restorBtn?;
	    private _followLineTop?;
	    private _followLineDown?;
	    private _slider?;
	    private _buttonList;
	    private onLoad;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestGridLayout' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestGridLayout {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _TestGridLayout?;
	    private _buttonList;
	    private onLoad;
	    private addContent;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestImage' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestImage {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _TestImage?;
	    private source;
	    private _buttonList;
	    private onLoad;
	    private insertGifParser;
	    private onHover;
	    private posY;
	    private getButton;
	    private onRelease;
	    private gifParser;
	}

}
declare module 'test/TestIsosceles' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestIsosceles {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _isosceles?;
	    private _buttonList;
	    private onLoad;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestLabel' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestLabel {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _TestLabel?;
	    private _buttonList;
	    private onLoad;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestMatter' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestImage {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    private getButton;
	    private getSlider;
	    private importScript;
	}

}
declare module 'test/TestMouseCursor' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestMouseCursor {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _help?;
	    private _wait?;
	    private _crosshair?;
	    private _notAllowed?;
	    private _zoomIn?;
	    private _grab?;
	    private _img?;
	    private _buttonList;
	    private onLoad;
	    private getContainer;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestMove' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestMove {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	}

}
declare module 'test/TestPathTimeLine' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestRect {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _rect?;
	    private _rectPoint?;
	    private _rect1?;
	    private _buttonList;
	    private onRelease;
	    private onLoad;
	    private onClick;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestPolygon' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestStar {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestRect' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestRect {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _rect?;
	    private _rectPoint?;
	    private _rect1?;
	    private _buttonList;
	    private onRelease;
	    private onLoad;
	    private onClick;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestScrollBar' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestScrollBar {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _title?;
	    private _testScrollBar?;
	    private _buttonList;
	    private onLoad;
	    private getScrollingContainer;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestScrollingContainer' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestScrollingContainer {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _testScrollingContainerX?;
	    private _testScrollingContainerY?;
	    private _testScrollingContainerXY?;
	    private _buttonList;
	    private onLoad;
	    private addSc;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestSlider' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestButton {
	    private _slider?;
	    private _buttonList;
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onRelease;
	    private onLoad;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestSpriteAnimated' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestSpriteAnimated {
	    private _sheetAnimated?;
	    private _buttonList;
	    private onLoad;
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestStar' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestStar {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _star?;
	    private _buttonList;
	    private onRelease;
	    private onLoad;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestStyle' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestStyle {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _label?;
	    private _rect?;
	    private _buttonList;
	    private onRelease;
	    private onLoad;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestSyncInteraction' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestSyncInteraction {
	    private id;
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	}

}
declare module 'test/TestTextInput' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestButton {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _textInput?;
	    private _buttonList;
	    private onLoad;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestTicker' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestTicker {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    private update;
	    private onRelease;
	}

}
declare module 'test/TestTimeLine' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestAnimationJitter {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    private aaa;
	    private hasAdd;
	    private start;
	    private step;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestToDivPoint' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestToDivPoint {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _TestImage?;
	    private _buttonList;
	    private onLoad;
	    private onHover;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestTracing' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestTracing {
	    private tracing;
	    private tracing2;
	    private _buttonList;
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onRelease;
	    private onLoad;
	    private getNewRadio;
	    private onChange;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestTween' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestTween {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    protected createBiTree(node: Node, layer: number): void;
	    private posY;
	    private getButton;
	} class Node {
	    constructor(parent?: Node, root?: vf.gui.Container);
	    div: any;
	    parent?: Node;
	    isLeft: boolean;
	    leftChild?: Node;
	    rightChild?: Node;
	}
	export {};

}
declare module 'test/TestTween2' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestTween2 {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	}

}
declare module 'test/TestVideo' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestVideo {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _TestVideo?;
	    private _TestVideo1?;
	    private _TestVideo2?;
	    private _buttonList;
	    private onLoad;
	    private createBtn;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/index' {
	///   path="../gui.d.ts" />
	export {};

}

    declare namespace vf.gui{
        export * from "src/UI";
    }
    declare module 'test/TestAlert' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestAlert {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    onLoad(app: vf.Application, uiStage: vf.gui.Stage): void;
	    alertClicked(target: any, index: number): void;
	}

}
declare module 'test/TestAlign' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestAlign {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	}

}
declare module 'test/TestAnimationJitter' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestAnimationJitter {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    private callBack;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestApplication' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestApplication {
	    constructor(thisObj: any, callback: (app: vf.Application, uiStage: vf.gui.Stage) => void);
	}

}
declare module 'test/TestArrow' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestArrow {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _arrow?;
	    private _buttonList;
	    private onLoad;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestAudio' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestAudio {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestAutoContainer' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestAutoContainer {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    onLoad(app: vf.Application, uiStage: vf.gui.Stage): void;
	}

}
declare module 'test/TestButton' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestButton {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _TestButton?;
	    private _buttonList;
	    private onLoad;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestCamera' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestCamera {
	    private sss;
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    video: import("src/display/Video").Video;
	    sprite: vf.Sprite;
	    private stream;
	    private errorFunc;
	    private openMedia;
	    private closeMedia;
	    /**
	     * 初始化完成后，外部触发调用
	     */
	    onLoad(): void;
	    /**
	     * 卸载
	     */
	    release(): void;
	    /**
	     * 更新显示
	     * @param unscaledWidth
	     * @param unscaledHeight
	     */
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	}

}
declare module 'test/TestCheckBox' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestCheckBox {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _TestCheckBox?;
	    private onLoad;
	    private getNewCheckBox;
	    private getNewRadio;
	    private onChange;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestCircle' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestCircle {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _circle?;
	    private _circle1?;
	    private _circle2?;
	    private _buttonList;
	    private onLoad;
	    private onClick;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestConnectLine' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestConnectLine {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _connectLine1?;
	    private _connectLine2?;
	    private _connectLine3?;
	    private _container?;
	    private _rect1?;
	    private _rect2?;
	    private _e4Rect1?;
	    private _e4Rect2?;
	    private _e4Line1?;
	    private _buttonList;
	    private _timeOutId;
	    private onLoad;
	    private getNewRect;
	    private getNewConnectLine;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestContainer' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestContainer {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _container1?;
	    private _container2?;
	    private _container3?;
	    private _container4?;
	    private _container5?;
	    private _container6?;
	    private _containerTop?;
	    private _containerLeft?;
	    private _containerRight?;
	    private _containerBottom?;
	    private _buttonList;
	    private onLoad;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestDrag' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestDrag {
	    private id;
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    private getNewContainer;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestEllipse' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestCircle {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestFillColor' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestRect {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _buttonList;
	    private onLoad;
	    private allG;
	    private getRandomRGBA;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestFollowLine' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestFollowLine {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _eraseBtn?;
	    private _restorBtn?;
	    private _followLineTop?;
	    private _followLineDown?;
	    private _slider?;
	    private _buttonList;
	    private onLoad;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestGridLayout' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestGridLayout {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _TestGridLayout?;
	    private _buttonList;
	    private onLoad;
	    private addContent;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestImage' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestImage {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _TestImage?;
	    private source;
	    private _buttonList;
	    private onLoad;
	    private insertGifParser;
	    private onHover;
	    private posY;
	    private getButton;
	    private onRelease;
	    private gifParser;
	}

}
declare module 'test/TestIsosceles' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestIsosceles {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _isosceles?;
	    private _buttonList;
	    private onLoad;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestLabel' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestLabel {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _TestLabel?;
	    private _buttonList;
	    private onLoad;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestMatter' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestImage {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    private getButton;
	    private getSlider;
	    private importScript;
	}

}
declare module 'test/TestMouseCursor' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestMouseCursor {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _help?;
	    private _wait?;
	    private _crosshair?;
	    private _notAllowed?;
	    private _zoomIn?;
	    private _grab?;
	    private _img?;
	    private _buttonList;
	    private onLoad;
	    private getContainer;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestMove' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestMove {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	}

}
declare module 'test/TestPathTimeLine' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestRect {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _rect?;
	    private _rectPoint?;
	    private _rect1?;
	    private _buttonList;
	    private onRelease;
	    private onLoad;
	    private onClick;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestPolygon' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestStar {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestRect' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestRect {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _rect?;
	    private _rectPoint?;
	    private _rect1?;
	    private _buttonList;
	    private onRelease;
	    private onLoad;
	    private onClick;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestScrollBar' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestScrollBar {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _title?;
	    private _testScrollBar?;
	    private _buttonList;
	    private onLoad;
	    private getScrollingContainer;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestScrollingContainer' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestScrollingContainer {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _testScrollingContainerX?;
	    private _testScrollingContainerY?;
	    private _testScrollingContainerXY?;
	    private _buttonList;
	    private onLoad;
	    private addSc;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestSlider' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestButton {
	    private _slider?;
	    private _buttonList;
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onRelease;
	    private onLoad;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestSpriteAnimated' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestSpriteAnimated {
	    private _sheetAnimated?;
	    private _buttonList;
	    private onLoad;
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestStar' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestStar {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _star?;
	    private _buttonList;
	    private onRelease;
	    private onLoad;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestStyle' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestStyle {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _label?;
	    private _rect?;
	    private _buttonList;
	    private onRelease;
	    private onLoad;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestSyncInteraction' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestSyncInteraction {
	    private id;
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	}

}
declare module 'test/TestTextInput' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestButton {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _textInput?;
	    private _buttonList;
	    private onLoad;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestTicker' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestTicker {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    private update;
	    private onRelease;
	}

}
declare module 'test/TestTimeLine' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestAnimationJitter {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    private aaa;
	    private hasAdd;
	    private start;
	    private step;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestToDivPoint' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestToDivPoint {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _TestImage?;
	    private _buttonList;
	    private onLoad;
	    private onHover;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestTracing' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestTracing {
	    private tracing;
	    private tracing2;
	    private _buttonList;
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onRelease;
	    private onLoad;
	    private getNewRadio;
	    private onChange;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestTween' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestTween {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    protected createBiTree(node: Node, layer: number): void;
	    private posY;
	    private getButton;
	} class Node {
	    constructor(parent?: Node, root?: vf.gui.Container);
	    div: import("src/display/Container").Container;
	    parent?: Node;
	    isLeft: boolean;
	    leftChild?: Node;
	    rightChild?: Node;
	}
	export {};

}
declare module 'test/TestTween2' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestTween2 {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	}

}
declare module 'test/TestVideo' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestVideo {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _TestVideo?;
	    private _TestVideo1?;
	    private _TestVideo2?;
	    private _buttonList;
	    private onLoad;
	    private createBtn;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/index' {
	///   path="../gui.d.ts" />
	export {};

}

    declare namespace vf.gui{
        export * from "src/UI";
    }
    declare module 'test/TestAlert' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestAlert {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    onLoad(app: vf.Application, uiStage: vf.gui.Stage): void;
	    alertClicked(target: any, index: number): void;
	}

}
declare module 'test/TestAlign' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestAlign {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	}

}
declare module 'test/TestAnimationJitter' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestAnimationJitter {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    private callBack;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestApplication' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestApplication {
	    constructor(thisObj: any, callback: (app: vf.Application, uiStage: vf.gui.Stage) => void);
	}

}
declare module 'test/TestArrow' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestArrow {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _arrow?;
	    private _buttonList;
	    private onLoad;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestAudio' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestAudio {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestAutoContainer' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestAutoContainer {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    onLoad(app: vf.Application, uiStage: vf.gui.Stage): void;
	}

}
declare module 'test/TestButton' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestButton {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _TestButton?;
	    private _buttonList;
	    private onLoad;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestCamera' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestCamera {
	    private sss;
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    video: import("src/display/Video").Video;
	    sprite: vf.Sprite;
	    private stream;
	    private errorFunc;
	    private openMedia;
	    private closeMedia;
	    /**
	     * 初始化完成后，外部触发调用
	     */
	    onLoad(): void;
	    /**
	     * 卸载
	     */
	    release(): void;
	    /**
	     * 更新显示
	     * @param unscaledWidth
	     * @param unscaledHeight
	     */
	    protected updateDisplayList(unscaledWidth: number, unscaledHeight: number): void;
	}

}
declare module 'test/TestCheckBox' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestCheckBox {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _TestCheckBox?;
	    private onLoad;
	    private getNewCheckBox;
	    private getNewRadio;
	    private onChange;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestCircle' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestCircle {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _circle?;
	    private _circle1?;
	    private _circle2?;
	    private _buttonList;
	    private onLoad;
	    private onClick;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestConnectLine' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestConnectLine {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _connectLine1?;
	    private _connectLine2?;
	    private _connectLine3?;
	    private _container?;
	    private _rect1?;
	    private _rect2?;
	    private _e4Rect1?;
	    private _e4Rect2?;
	    private _e4Line1?;
	    private _buttonList;
	    private _timeOutId;
	    private onLoad;
	    private getNewRect;
	    private getNewConnectLine;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestContainer' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestContainer {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _container1?;
	    private _container2?;
	    private _container3?;
	    private _container4?;
	    private _container5?;
	    private _container6?;
	    private _containerTop?;
	    private _containerLeft?;
	    private _containerRight?;
	    private _containerBottom?;
	    private _buttonList;
	    private onLoad;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestDrag' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestDrag {
	    private id;
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    private getNewContainer;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestEllipse' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestCircle {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestFillColor' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestRect {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _buttonList;
	    private onLoad;
	    private allG;
	    private getRandomRGBA;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestFollowLine' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestFollowLine {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _eraseBtn?;
	    private _restorBtn?;
	    private _followLineTop?;
	    private _followLineDown?;
	    private _slider?;
	    private _buttonList;
	    private onLoad;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestGridLayout' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestGridLayout {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _TestGridLayout?;
	    private _buttonList;
	    private onLoad;
	    private addContent;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestImage' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestImage {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _TestImage?;
	    private source;
	    private _buttonList;
	    private onLoad;
	    private insertGifParser;
	    private onHover;
	    private posY;
	    private getButton;
	    private onRelease;
	    private gifParser;
	}

}
declare module 'test/TestIsosceles' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestIsosceles {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _isosceles?;
	    private _buttonList;
	    private onLoad;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestLabel' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestLabel {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _TestLabel?;
	    private _buttonList;
	    private onLoad;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestMatter' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestImage {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    private getButton;
	    private getSlider;
	    private importScript;
	}

}
declare module 'test/TestMouseCursor' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestMouseCursor {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _help?;
	    private _wait?;
	    private _crosshair?;
	    private _notAllowed?;
	    private _zoomIn?;
	    private _grab?;
	    private _img?;
	    private _buttonList;
	    private onLoad;
	    private getContainer;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestMove' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestMove {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	}

}
declare module 'test/TestPathTimeLine' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestRect {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _rect?;
	    private _rectPoint?;
	    private _rect1?;
	    private _buttonList;
	    private onRelease;
	    private onLoad;
	    private onClick;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestPolygon' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestStar {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestRect' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestRect {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _rect?;
	    private _rectPoint?;
	    private _rect1?;
	    private _buttonList;
	    private onRelease;
	    private onLoad;
	    private onClick;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestScrollBar' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestScrollBar {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _title?;
	    private _testScrollBar?;
	    private _buttonList;
	    private onLoad;
	    private getScrollingContainer;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestScrollingContainer' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestScrollingContainer {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _testScrollingContainerX?;
	    private _testScrollingContainerY?;
	    private _testScrollingContainerXY?;
	    private _buttonList;
	    private onLoad;
	    private addSc;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestSlider' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestButton {
	    private _slider?;
	    private _buttonList;
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onRelease;
	    private onLoad;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestSpriteAnimated' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestSpriteAnimated {
	    private _sheetAnimated?;
	    private _buttonList;
	    private onLoad;
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestStar' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestStar {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _star?;
	    private _buttonList;
	    private onRelease;
	    private onLoad;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestStyle' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestStyle {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _label?;
	    private _rect?;
	    private _buttonList;
	    private onRelease;
	    private onLoad;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestSyncInteraction' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestSyncInteraction {
	    private id;
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	}

}
declare module 'test/TestTextInput' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestButton {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _textInput?;
	    private _buttonList;
	    private onLoad;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestTicker' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestTicker {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    private update;
	    private onRelease;
	}

}
declare module 'test/TestTimeLine' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestAnimationJitter {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    private aaa;
	    private hasAdd;
	    private start;
	    private step;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestToDivPoint' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestToDivPoint {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _TestImage?;
	    private _buttonList;
	    private onLoad;
	    private onHover;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/TestTracing' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestTracing {
	    private tracing;
	    private tracing2;
	    private _buttonList;
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onRelease;
	    private onLoad;
	    private getNewRadio;
	    private onChange;
	    private posY;
	    private getButton;
	}

}
declare module 'test/TestTween' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestTween {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	    protected createBiTree(node: Node, layer: number): void;
	    private posY;
	    private getButton;
	} class Node {
	    constructor(parent?: Node, root?: vf.gui.Container);
	    div: import("src/display/Container").Container;
	    parent?: Node;
	    isLeft: boolean;
	    leftChild?: Node;
	    rightChild?: Node;
	}
	export {};

}
declare module 'test/TestTween2' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestTween2 {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private onLoad;
	}

}
declare module 'test/TestVideo' {
	///   path="../gui.d.ts" />
	///   types="@vf.js/vf" />
	export default class TestVideo {
	    constructor(app: vf.Application, uiStage: vf.gui.Stage);
	    private _TestVideo?;
	    private _TestVideo1?;
	    private _TestVideo2?;
	    private _buttonList;
	    private onLoad;
	    private createBtn;
	    private posY;
	    private getButton;
	    private onRelease;
	}

}
declare module 'test/index' {
	///   path="../gui.d.ts" />
	export {};

}

    declare namespace vf.gui{
        export * from "src/UI";
    }
    