/// <reference types="webxr" />
declare const _default: () => import("vue").Ref<{
    domElement: HTMLCanvasElement;
    autoClear: boolean;
    autoClearColor: boolean;
    autoClearDepth: boolean;
    autoClearStencil: boolean;
    debug: {
        checkShaderErrors: boolean;
    };
    sortObjects: boolean;
    clippingPlanes: any[];
    localClippingEnabled: boolean;
    extensions: {
        has: (name: string) => boolean;
        init: (capabilities: import("three").WebGLCapabilities) => void;
        get: (name: string) => any;
    };
    outputEncoding: import("three").TextureEncoding;
    physicallyCorrectLights: boolean;
    toneMapping: import("three").ToneMapping;
    toneMappingExposure: number;
    info: {
        autoReset: boolean;
        memory: {
            geometries: number;
            textures: number;
        };
        programs: {
            name: string;
            id: number;
            cacheKey: string;
            usedTimes: number;
            program: any;
            vertexShader: WebGLShader;
            fragmentShader: WebGLShader;
            uniforms: any;
            attributes: any;
            getUniforms: () => import("three").WebGLUniforms;
            getAttributes: () => any;
            destroy: () => void;
        }[] | null;
        render: {
            calls: number;
            frame: number;
            lines: number;
            points: number;
            triangles: number;
        };
        update: (count: number, mode: number, instanceCount: number) => void;
        reset: () => void;
    };
    shadowMap: {
        enabled: boolean;
        autoUpdate: boolean;
        needsUpdate: boolean;
        type: import("three").ShadowMapType;
        render: (shadowsArray: import("three").Light[], scene: import("three").Scene, camera: import("three").Camera) => void;
        cullFace: any;
    };
    pixelRatio: number;
    capabilities: {
        readonly isWebGL2: boolean;
        precision: string;
        logarithmicDepthBuffer: boolean;
        maxTextures: number;
        maxVertexTextures: number;
        maxTextureSize: number;
        maxCubemapSize: number;
        maxAttributes: number;
        maxVertexUniforms: number;
        maxVaryings: number;
        maxFragmentUniforms: number;
        vertexTextures: boolean;
        floatFragmentTextures: boolean;
        floatVertexTextures: boolean;
        maxSamples: number;
        getMaxAnisotropy: () => number;
        getMaxPrecision: (precision: string) => string;
    };
    properties: {
        get: (object: any) => any;
        remove: (object: any) => void;
        update: (object: any, key: any, value: any) => any;
        dispose: () => void;
    };
    renderLists: {
        dispose: () => void;
        get: (scene: import("three").Scene, renderCallDepth: number) => import("three").WebGLRenderList;
    };
    state: {
        buffers: {
            color: {
                setMask: (colorMask: boolean) => void;
                setLocked: (lock: boolean) => void;
                setClear: (r: number, g: number, b: number, a: number, premultipliedAlpha: boolean) => void;
                reset: () => void;
            };
            depth: {
                setTest: (depthTest: boolean) => void;
                setMask: (depthMask: boolean) => void;
                setFunc: (depthFunc: import("three").DepthModes) => void;
                setLocked: (lock: boolean) => void;
                setClear: (depth: number) => void;
                reset: () => void;
            };
            stencil: {
                setTest: (stencilTest: boolean) => void;
                setMask: (stencilMask: number) => void;
                setFunc: (stencilFunc: number, stencilRef: number, stencilMask: number) => void;
                setOp: (stencilFail: number, stencilZFail: number, stencilZPass: number) => void;
                setLocked: (lock: boolean) => void;
                setClear: (stencil: number) => void;
                reset: () => void;
            };
        };
        initAttributes: () => void;
        enableAttribute: (attribute: number) => void;
        enableAttributeAndDivisor: (attribute: number, meshPerAttribute: number) => void;
        disableUnusedAttributes: () => void;
        vertexAttribPointer: (index: number, size: number, type: number, normalized: boolean, stride: number, offset: number) => void;
        enable: (id: number) => void;
        disable: (id: number) => void;
        bindFramebuffer: (target: number, framebuffer: WebGLFramebuffer | null) => void;
        bindXRFramebuffer: (framebuffer: WebGLFramebuffer | null) => void;
        useProgram: (program: any) => boolean;
        setBlending: (blending: import("three").Blending, blendEquation?: import("three").BlendingEquation | undefined, blendSrc?: import("three").BlendingSrcFactor | undefined, blendDst?: import("three").BlendingDstFactor | undefined, blendEquationAlpha?: import("three").BlendingEquation | undefined, blendSrcAlpha?: import("three").BlendingSrcFactor | undefined, blendDstAlpha?: import("three").BlendingDstFactor | undefined, premultiplyAlpha?: boolean | undefined) => void;
        setMaterial: (material: import("three").Material, frontFaceCW: boolean) => void;
        setFlipSided: (flipSided: boolean) => void;
        setCullFace: (cullFace: import("three").CullFace) => void;
        setLineWidth: (width: number) => void;
        setPolygonOffset: (polygonoffset: boolean, factor?: number | undefined, units?: number | undefined) => void;
        setScissorTest: (scissorTest: boolean) => void;
        activeTexture: (webglSlot: number) => void;
        bindTexture: (webglType: number, webglTexture: any) => void;
        unbindTexture: () => void;
        compressedTexImage2D: (target: number, level: number, internalformat: number, width: number, height: number, border: number, data: ArrayBufferView) => void;
        texImage2D: {
            (target: number, level: number, internalformat: number, width: number, height: number, border: number, format: number, type: number, pixels: ArrayBufferView | null): void;
            (target: number, level: number, internalformat: number, format: number, type: number, source: any): void;
        };
        texImage3D: (target: number, level: number, internalformat: number, width: number, height: number, depth: number, border: number, format: number, type: number, pixels: any) => void;
        scissor: (scissor: import("three").Vector4) => void;
        viewport: (viewport: import("three").Vector4) => void;
        reset: () => void;
    };
    xr: {
        enabled: boolean;
        isPresenting: boolean;
        cameraAutoUpdate: boolean;
        getController: (index: number) => import("three").XRTargetRaySpace;
        getControllerGrip: (index: number) => import("three").XRGripSpace;
        getHand: (index: number) => import("three").XRHandSpace;
        setFramebufferScaleFactor: (value: number) => void;
        setReferenceSpaceType: (value: XRReferenceSpaceType) => void;
        getReferenceSpace: () => XRReferenceSpace | null;
        setReferenceSpace: (value: XRReferenceSpace) => void;
        getBaseLayer: () => XRWebGLLayer | XRProjectionLayer;
        getBinding: () => XRWebGLBinding;
        getFrame: () => XRFrame;
        getSession: () => XRSession | null;
        setSession: (value: XRSession | null) => Promise<void>;
        getCamera: () => import("three").WebXRArrayCamera;
        updateCamera: (camera: import("three").PerspectiveCamera) => void;
        setAnimationLoop: (callback: XRFrameRequestCallback | null) => void;
        getFoveation: () => number | undefined;
        setFoveation: (value: number) => void;
        getPlanes: () => Set<XRPlane>;
        dispose: () => void;
        addEventListener: <T extends string>(type: T, listener: import("three").EventListener<import("three").Event, T, import("three").WebXRManager>) => void;
        hasEventListener: <T_1 extends string>(type: T_1, listener: import("three").EventListener<import("three").Event, T_1, import("three").WebXRManager>) => boolean;
        removeEventListener: <T_2 extends string>(type: T_2, listener: import("three").EventListener<import("three").Event, T_2, import("three").WebXRManager>) => void;
        dispatchEvent: (event: import("three").Event) => void;
    };
    getContext: () => WebGLRenderingContext | WebGL2RenderingContext;
    getContextAttributes: () => any;
    forceContextLoss: () => void;
    forceContextRestore: () => void;
    getMaxAnisotropy: () => number;
    getPrecision: () => string;
    getPixelRatio: () => number;
    setPixelRatio: (value: number) => void;
    getDrawingBufferSize: (target: import("three").Vector2) => import("three").Vector2;
    setDrawingBufferSize: (width: number, height: number, pixelRatio: number) => void;
    getSize: (target: import("three").Vector2) => import("three").Vector2;
    setSize: (width: number, height: number, updateStyle?: boolean | undefined) => void;
    getCurrentViewport: (target: import("three").Vector4) => import("three").Vector4;
    getViewport: (target: import("three").Vector4) => import("three").Vector4;
    setViewport: (x: number | import("three").Vector4, y?: number | undefined, width?: number | undefined, height?: number | undefined) => void;
    getScissor: (target: import("three").Vector4) => import("three").Vector4;
    setScissor: (x: number | import("three").Vector4, y?: number | undefined, width?: number | undefined, height?: number | undefined) => void;
    getScissorTest: () => boolean;
    setScissorTest: (enable: boolean) => void;
    setOpaqueSort: (method: (a: any, b: any) => number) => void;
    setTransparentSort: (method: (a: any, b: any) => number) => void;
    getClearColor: (target: import("three").Color) => import("three").Color;
    setClearColor: (color: import("three").ColorRepresentation, alpha?: number | undefined) => void;
    getClearAlpha: () => number;
    setClearAlpha: (alpha: number) => void;
    clear: (color?: boolean | undefined, depth?: boolean | undefined, stencil?: boolean | undefined) => void;
    clearColor: () => void;
    clearDepth: () => void;
    clearStencil: () => void;
    clearTarget: (renderTarget: import("three").WebGLRenderTarget, color: boolean, depth: boolean, stencil: boolean) => void;
    resetGLState: () => void;
    dispose: () => void;
    renderBufferDirect: (camera: import("three").Camera, scene: import("three").Scene, geometry: import("three").BufferGeometry, material: import("three").Material, object: import("three").Object3D<import("three").Event>, geometryGroup: any) => void;
    setAnimationLoop: (callback: XRFrameRequestCallback | null) => void;
    animate: (callback: () => void) => void;
    compile: (scene: import("three").Object3D<import("three").Event>, camera: import("three").Camera) => void;
    render: (scene: import("three").Object3D<import("three").Event>, camera: import("three").Camera) => void;
    getActiveCubeFace: () => number;
    getActiveMipmapLevel: () => number;
    getRenderTarget: () => import("three").WebGLRenderTarget | null;
    getCurrentRenderTarget: () => import("three").WebGLRenderTarget | null;
    setRenderTarget: (renderTarget: import("three").WebGLRenderTarget | import("three").WebGLMultipleRenderTargets | null, activeCubeFace?: number | undefined, activeMipmapLevel?: number | undefined) => void;
    readRenderTargetPixels: (renderTarget: import("three").WebGLRenderTarget | import("three").WebGLMultipleRenderTargets, x: number, y: number, width: number, height: number, buffer: any, activeCubeFaceIndex?: number | undefined) => void;
    copyFramebufferToTexture: (position: import("three").Vector2, texture: import("three").Texture, level?: number | undefined) => void;
    copyTextureToTexture: (position: import("three").Vector2, srcTexture: import("three").Texture, dstTexture: import("three").Texture, level?: number | undefined) => void;
    copyTextureToTexture3D: (sourceBox: import("three").Box3, position: import("three").Vector3, srcTexture: import("three").Texture, dstTexture: import("three").Data3DTexture | import("three").DataArrayTexture, level?: number | undefined) => void;
    initTexture: (texture: import("three").Texture) => void;
    resetState: () => void;
    vr: boolean;
    shadowMapEnabled: boolean;
    shadowMapType: import("three").ShadowMapType;
    shadowMapCullFace: import("three").CullFace;
    supportsFloatTextures: () => any;
    supportsHalfFloatTextures: () => any;
    supportsStandardDerivatives: () => any;
    supportsCompressedTextureS3TC: () => any;
    supportsCompressedTexturePVRTC: () => any;
    supportsBlendMinMax: () => any;
    supportsVertexTextures: () => any;
    supportsInstancedArrays: () => any;
    enableScissorTest: (boolean: any) => any;
} | undefined>;
export default _default;