import * as vue from 'vue';
import { MouseMovePayload, PointerLockChangePayload, PageVisibilityPayload, FullscreenChangePayload, DeviceTypeChangePayload, ResizePayload, ScreenOrientationChangePayload, PageFocusChangePayload, MouseScrollPayload, KeyDownPayload, KeyUpPayload, LeftMouseButtonDownPayload, MiddleMouseButtonDownPayload, RightMouseButtonDownPayload, LeftMouseButtonUpPayload, MiddleMouseButtonUpPayload, RightMouseButtonUpPayload, MainLoopEffectCallback, MainLoopEffectOptions, Joystick } from '@manapotion/core';
export * from '@manapotion/core';

declare const Listeners: vue.DefineComponent<{
    mouseMovementResetDelay: {
        type: NumberConstructor;
    };
    mouseScrollResetDelay: {
        type: NumberConstructor;
    };
}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>[], unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    mouseMove: (payload: MouseMovePayload) => MouseMovePayload;
    pointerLockChange: (payload: PointerLockChangePayload) => PointerLockChangePayload;
    pageVisibilityChange: (payload: PageVisibilityPayload) => PageVisibilityPayload;
    fullscreenChange: (payload: FullscreenChangePayload) => FullscreenChangePayload;
    deviceTypeChange: (payload: DeviceTypeChangePayload) => DeviceTypeChangePayload;
    resize: (payload: ResizePayload) => ResizePayload;
    screenOrientationChange: (payload: ScreenOrientationChangePayload) => ScreenOrientationChangePayload;
    pageFocusChange: (payload: PageFocusChangePayload) => PageFocusChangePayload;
    scroll: (payload: MouseScrollPayload) => MouseScrollPayload;
    keyDown: (payload: KeyDownPayload) => {
        code: string;
        key: string;
        ctrl: boolean;
        shift: boolean;
        alt: boolean;
        meta: boolean;
    };
    keyUp: (payload: KeyUpPayload) => {
        code: string;
        key: string;
        ctrl: boolean;
        shift: boolean;
        alt: boolean;
        meta: boolean;
    };
    leftMouseDown: (payload: LeftMouseButtonDownPayload) => LeftMouseButtonDownPayload;
    middleMouseDown: (payload: MiddleMouseButtonDownPayload) => MiddleMouseButtonDownPayload;
    rightMouseDown: (payload: RightMouseButtonDownPayload) => RightMouseButtonDownPayload;
    leftMouseUp: (payload: LeftMouseButtonUpPayload) => LeftMouseButtonUpPayload;
    middleMouseUp: (payload: MiddleMouseButtonUpPayload) => MiddleMouseButtonUpPayload;
    rightMouseUp: (payload: RightMouseButtonUpPayload) => RightMouseButtonUpPayload;
}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    mouseMovementResetDelay: {
        type: NumberConstructor;
    };
    mouseScrollResetDelay: {
        type: NumberConstructor;
    };
}>> & {
    onDeviceTypeChange?: ((payload: DeviceTypeChangePayload) => any) | undefined;
    onFullscreenChange?: ((payload: FullscreenChangePayload) => any) | undefined;
    onKeyDown?: ((payload: {
        code: string;
        key: string;
        ctrl: boolean;
        shift: boolean;
        alt: boolean;
        meta: boolean;
    }) => any) | undefined;
    onKeyUp?: ((payload: {
        code: string;
        key: string;
        ctrl: boolean;
        shift: boolean;
        alt: boolean;
        meta: boolean;
    }) => any) | undefined;
    onMouseMove?: ((payload: MouseMovePayload) => any) | undefined;
    onScroll?: ((payload: MouseScrollPayload) => any) | undefined;
    onPageFocusChange?: ((payload: PageFocusChangePayload) => any) | undefined;
    onPageVisibilityChange?: ((payload: PageVisibilityPayload) => any) | undefined;
    onPointerLockChange?: ((payload: PointerLockChangePayload) => any) | undefined;
    onResize?: ((payload: ResizePayload) => any) | undefined;
    onScreenOrientationChange?: ((payload: ScreenOrientationChangePayload) => any) | undefined;
    onLeftMouseDown?: ((payload: LeftMouseButtonDownPayload) => any) | undefined;
    onMiddleMouseDown?: ((payload: MiddleMouseButtonDownPayload) => any) | undefined;
    onRightMouseDown?: ((payload: RightMouseButtonDownPayload) => any) | undefined;
    onLeftMouseUp?: ((payload: LeftMouseButtonUpPayload) => any) | undefined;
    onMiddleMouseUp?: ((payload: MiddleMouseButtonUpPayload) => any) | undefined;
    onRightMouseUp?: ((payload: RightMouseButtonUpPayload) => any) | undefined;
}, {}, {}>;

declare const browser: {
    readonly isFullscreen: boolean;
    readonly isPageVisible: boolean;
    readonly isPageFocused: boolean;
    readonly isDesktop: boolean;
    readonly isMobile: boolean;
    readonly isPortrait: boolean;
    readonly isLandscape: boolean;
    readonly width: number;
    readonly height: number;
    readonly pointerLockSupported: boolean;
};
declare const mouse: {
    readonly locked: boolean;
    readonly position: {
        readonly x: number;
        readonly y: number;
    };
    readonly movement: {
        readonly x: number;
        readonly y: number;
    };
    readonly wheel: {
        readonly y: number;
    };
    readonly buttons: {
        readonly left: boolean;
        readonly middle: boolean;
        readonly right: boolean;
    };
};
declare const keyboard: {
    readonly codes: Record<string, boolean>;
    readonly keys: Record<string, boolean>;
    readonly ctrl: boolean;
    readonly shift: boolean;
    readonly alt: boolean;
    readonly meta: boolean;
};
declare const joysticks: {
    movement: {
        isActive: boolean;
        identifier: number | null;
        origin: {
            x: number | null;
            y: number | null;
            angle: number | null;
            distance: number | null;
            distanceRatio: number | null;
        };
        follow: {
            x: number | null;
            y: number | null;
            angle: number | null;
            distance: number | null;
            distanceRatio: number | null;
        };
        current: {
            x: number | null;
            y: number | null;
        };
        movement: {
            x: number;
            y: number;
        };
    };
    rotation: {
        isActive: boolean;
        identifier: number | null;
        origin: {
            x: number | null;
            y: number | null;
            angle: number | null;
            distance: number | null;
            distanceRatio: number | null;
        };
        follow: {
            x: number | null;
            y: number | null;
            angle: number | null;
            distance: number | null;
            distanceRatio: number | null;
        };
        current: {
            x: number | null;
            y: number | null;
        };
        movement: {
            x: number;
            y: number;
        };
    };
};

declare const useMainLoop: (callback: MainLoopEffectCallback, options?: MainLoopEffectOptions) => void;

declare const JoystickArea: vue.DefineComponent<{
    mode: {
        type: () => "follow" | "origin";
        default: string;
    };
    joystick: {
        type: () => Joystick;
        required: true;
    };
    maxFollowDistance: {
        type: NumberConstructor;
    };
    maxOriginDistance: {
        type: NumberConstructor;
    };
    onEnd: {
        type: FunctionConstructor;
    };
    onMove: {
        type: FunctionConstructor;
    };
    onStart: {
        type: FunctionConstructor;
    };
    containerProps: {
        type: ObjectConstructor;
    };
}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    mode: {
        type: () => "follow" | "origin";
        default: string;
    };
    joystick: {
        type: () => Joystick;
        required: true;
    };
    maxFollowDistance: {
        type: NumberConstructor;
    };
    maxOriginDistance: {
        type: NumberConstructor;
    };
    onEnd: {
        type: FunctionConstructor;
    };
    onMove: {
        type: FunctionConstructor;
    };
    onStart: {
        type: FunctionConstructor;
    };
    containerProps: {
        type: ObjectConstructor;
    };
}>>, {
    mode: "origin" | "follow";
}, {}>;

declare const DeviceTypeListener: vue.DefineComponent<{}, void, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    deviceTypeChange: (payload: DeviceTypeChangePayload) => DeviceTypeChangePayload;
}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>> & {
    onDeviceTypeChange?: ((payload: DeviceTypeChangePayload) => any) | undefined;
}, {}, {}>;

declare const KeyboardListener: vue.DefineComponent<{}, void, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    keyDown: (payload: KeyDownPayload) => {
        code: string;
        key: string;
        ctrl: boolean;
        shift: boolean;
        alt: boolean;
        meta: boolean;
    };
    keyUp: (payload: KeyUpPayload) => {
        code: string;
        key: string;
        ctrl: boolean;
        shift: boolean;
        alt: boolean;
        meta: boolean;
    };
}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>> & {
    onKeyDown?: ((payload: {
        code: string;
        key: string;
        ctrl: boolean;
        shift: boolean;
        alt: boolean;
        meta: boolean;
    }) => any) | undefined;
    onKeyUp?: ((payload: {
        code: string;
        key: string;
        ctrl: boolean;
        shift: boolean;
        alt: boolean;
        meta: boolean;
    }) => any) | undefined;
}, {}, {}>;

declare const FullscreenListener: vue.DefineComponent<{}, void, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    fullscreenChange: (payload: FullscreenChangePayload) => FullscreenChangePayload;
}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>> & {
    onFullscreenChange?: ((payload: FullscreenChangePayload) => any) | undefined;
}, {}, {}>;

declare const MouseButtonsListener: vue.DefineComponent<{}, void, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    leftMouseButtonDown: (payload: LeftMouseButtonDownPayload) => LeftMouseButtonDownPayload;
    middleMouseButtonDown: (payload: MiddleMouseButtonDownPayload) => MiddleMouseButtonDownPayload;
    rightMouseButtonDown: (payload: RightMouseButtonDownPayload) => RightMouseButtonDownPayload;
    leftMouseButtonUp: (payload: LeftMouseButtonUpPayload) => LeftMouseButtonUpPayload;
    middleMouseButtonUp: (payload: MiddleMouseButtonUpPayload) => MiddleMouseButtonUpPayload;
    rightMouseButtonUp: (payload: RightMouseButtonUpPayload) => RightMouseButtonUpPayload;
}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>> & {
    onLeftMouseButtonDown?: ((payload: LeftMouseButtonDownPayload) => any) | undefined;
    onMiddleMouseButtonDown?: ((payload: MiddleMouseButtonDownPayload) => any) | undefined;
    onRightMouseButtonDown?: ((payload: RightMouseButtonDownPayload) => any) | undefined;
    onLeftMouseButtonUp?: ((payload: LeftMouseButtonUpPayload) => any) | undefined;
    onMiddleMouseButtonUp?: ((payload: MiddleMouseButtonUpPayload) => any) | undefined;
    onRightMouseButtonUp?: ((payload: RightMouseButtonUpPayload) => any) | undefined;
}, {}, {}>;

declare const MouseMoveListener: vue.DefineComponent<{
    mouseMovementResetDelay: {
        type: NumberConstructor;
    };
}, void, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    mouseMove: (payload: MouseMovePayload) => MouseMovePayload;
}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    mouseMovementResetDelay: {
        type: NumberConstructor;
    };
}>> & {
    onMouseMove?: ((payload: MouseMovePayload) => any) | undefined;
}, {}, {}>;

declare const MouseScrollListener: vue.DefineComponent<{
    mouseScrollResetDelay: {
        type: NumberConstructor;
    };
}, void, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    scroll: (payload: MouseScrollPayload) => MouseScrollPayload;
}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    mouseScrollResetDelay: {
        type: NumberConstructor;
    };
}>> & {
    onScroll?: ((payload: MouseScrollPayload) => any) | undefined;
}, {}, {}>;

declare const PageFocusListener: vue.DefineComponent<{}, void, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    pageFocusChange: (payload: PageFocusChangePayload) => PageFocusChangePayload;
}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>> & {
    onPageFocusChange?: ((payload: PageFocusChangePayload) => any) | undefined;
}, {}, {}>;

declare const PageVisibilityListener: vue.DefineComponent<{}, void, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    pageVisibilityChange: (payload: PageVisibilityPayload) => PageVisibilityPayload;
}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>> & {
    onPageVisibilityChange?: ((payload: PageVisibilityPayload) => any) | undefined;
}, {}, {}>;

declare const PointerLockListener: vue.DefineComponent<{}, void, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    pointerLockChange: (payload: PointerLockChangePayload) => PointerLockChangePayload;
}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>> & {
    onPointerLockChange?: ((payload: PointerLockChangePayload) => any) | undefined;
}, {}, {}>;

declare const ResizeListener: vue.DefineComponent<{}, void, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    resize: (payload: ResizePayload) => ResizePayload;
}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>> & {
    onResize?: ((payload: ResizePayload) => any) | undefined;
}, {}, {}>;

declare const ScreenOrientationListener: vue.DefineComponent<{}, void, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    screenOrientationChange: (payload: ScreenOrientationChangePayload) => ScreenOrientationChangePayload;
}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>> & {
    onScreenOrientationChange?: ((payload: ScreenOrientationChangePayload) => any) | undefined;
}, {}, {}>;

export { DeviceTypeListener, FullscreenListener, JoystickArea, KeyboardListener, Listeners, MouseButtonsListener, MouseMoveListener, MouseScrollListener, PageFocusListener, PageVisibilityListener, PointerLockListener, ResizeListener, ScreenOrientationListener, browser, joysticks, keyboard, mouse, useMainLoop };