@pixiv/three-vrm 0.6.4 → 0.6.8

package/types/firstperson/VRMFirstPersonImporter.d.ts

@@ -1,15 +1,15 @@
-import { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
-import { VRMHumanoid } from '../humanoid';
-import { VRMFirstPerson } from './VRMFirstPerson';
-/**
- * An importer that imports a [[VRMFirstPerson]] from a VRM extension of a GLTF.
- */
-export declare class VRMFirstPersonImporter {
-    /**
-     * Import a [[VRMFirstPerson]] from a VRM.
-     *
-     * @param gltf A parsed result of GLTF taken from GLTFLoader
-     * @param humanoid A [[VRMHumanoid]] instance that represents the VRM
-     */
-    import(gltf: GLTF, humanoid: VRMHumanoid): Promise<VRMFirstPerson | null>;
-}
+import { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
+import { VRMHumanoid } from '../humanoid';
+import { VRMFirstPerson } from './VRMFirstPerson';
+/**
+ * An importer that imports a [[VRMFirstPerson]] from a VRM extension of a GLTF.
+ */
+export declare class VRMFirstPersonImporter {
+    /**
+     * Import a [[VRMFirstPerson]] from a VRM.
+     *
+     * @param gltf A parsed result of GLTF taken from GLTFLoader
+     * @param humanoid A [[VRMHumanoid]] instance that represents the VRM
+     */
+    import(gltf: GLTF, humanoid: VRMHumanoid): Promise<VRMFirstPerson | null>;
+}

package/types/firstperson/index.d.ts

@@ -1,2 +1,2 @@
-export * from './VRMFirstPerson';
-export * from './VRMFirstPersonImporter';
+export * from './VRMFirstPerson';
+export * from './VRMFirstPersonImporter';

package/types/humanoid/VRMHumanBone.d.ts

@@ -1,22 +1,22 @@
-import { GLTFNode } from '../types';
-import { VRMHumanLimit } from './VRMHumanLimit';
-/**
- * A class represents a single `humanBone` of a VRM.
- */
-export declare class VRMHumanBone {
-    /**
-     * A [[GLTFNode]] (that actually is a `THREE.Object3D`) that represents the bone.
-     */
-    readonly node: GLTFNode;
-    /**
-     * A [[VRMHumanLimit]] object that represents properties of the bone.
-     */
-    readonly humanLimit: VRMHumanLimit;
-    /**
-     * Create a new VRMHumanBone.
-     *
-     * @param node A [[GLTFNode]] that represents the new bone
-     * @param humanLimit A [[VRMHumanLimit]] object that represents properties of the new bone
-     */
-    constructor(node: GLTFNode, humanLimit: VRMHumanLimit);
-}
+import { GLTFNode } from '../types';
+import { VRMHumanLimit } from './VRMHumanLimit';
+/**
+ * A class represents a single `humanBone` of a VRM.
+ */
+export declare class VRMHumanBone {
+    /**
+     * A [[GLTFNode]] (that actually is a `THREE.Object3D`) that represents the bone.
+     */
+    readonly node: GLTFNode;
+    /**
+     * A [[VRMHumanLimit]] object that represents properties of the bone.
+     */
+    readonly humanLimit: VRMHumanLimit;
+    /**
+     * Create a new VRMHumanBone.
+     *
+     * @param node A [[GLTFNode]] that represents the new bone
+     * @param humanLimit A [[VRMHumanLimit]] object that represents properties of the new bone
+     */
+    constructor(node: GLTFNode, humanLimit: VRMHumanLimit);
+}

package/types/humanoid/VRMHumanBoneArray.d.ts

@@ -1,9 +1,9 @@
-import { VRMSchema } from '../types';
-import { VRMHumanBone } from './VRMHumanBone';
-/**
- * An array represents a `vrm.humanoid.humanBones` field of VRM specification.
- */
-export declare type VRMHumanBoneArray = Array<{
-    name: VRMSchema.HumanoidBoneName;
-    bone: VRMHumanBone;
-}>;
+import { VRMSchema } from '../types';
+import { VRMHumanBone } from './VRMHumanBone';
+/**
+ * An array represents a `vrm.humanoid.humanBones` field of VRM specification.
+ */
+export declare type VRMHumanBoneArray = Array<{
+    name: VRMSchema.HumanoidBoneName;
+    bone: VRMHumanBone;
+}>;

package/types/humanoid/VRMHumanBones.d.ts

@@ -1,8 +1,8 @@
-import { VRMSchema } from '../types';
-import { VRMHumanBone } from './VRMHumanBone';
-/**
- * This object is a object variant of [[VRMHumanBoneArray]], used internally in [[VRMHumanoid]].
- */
-export declare type VRMHumanBones = {
-    [name in VRMSchema.HumanoidBoneName]: VRMHumanBone[];
-};
+import { VRMSchema } from '../types';
+import { VRMHumanBone } from './VRMHumanBone';
+/**
+ * This object is a object variant of [[VRMHumanBoneArray]], used internally in [[VRMHumanoid]].
+ */
+export declare type VRMHumanBones = {
+    [name in VRMSchema.HumanoidBoneName]: VRMHumanBone[];
+};

package/types/humanoid/VRMHumanDescription.d.ts

@@ -1,14 +1,14 @@
-/**
- * An interface represents a `HumanDescription` defined in VRM specification.
- * These fields are not used in this implementation.
- */
-export interface VRMHumanDescription {
-    armStretch?: number;
-    legStretch?: number;
-    upperArmTwist?: number;
-    lowerArmTwist?: number;
-    upperLegTwist?: number;
-    lowerLegTwist?: number;
-    feetSpacing?: number;
-    hasTranslationDoF?: boolean;
-}
+/**
+ * An interface represents a `HumanDescription` defined in VRM specification.
+ * These fields are not used in this implementation.
+ */
+export interface VRMHumanDescription {
+    armStretch?: number;
+    legStretch?: number;
+    upperArmTwist?: number;
+    lowerArmTwist?: number;
+    upperLegTwist?: number;
+    lowerLegTwist?: number;
+    feetSpacing?: number;
+    hasTranslationDoF?: boolean;
+}

package/types/humanoid/VRMHumanLimit.d.ts

@@ -1,12 +1,12 @@
-import * as THREE from 'three';
-/**
- * An interface represents a `HumanLimit` defined in VRM specification.
- * These fields are not used in this implementation.
- */
-export interface VRMHumanLimit {
-    useDefaultValues?: boolean;
-    min?: THREE.Vector3;
-    max?: THREE.Vector3;
-    center?: THREE.Vector3;
-    axisLength?: number;
-}
+import * as THREE from 'three';
+/**
+ * An interface represents a `HumanLimit` defined in VRM specification.
+ * These fields are not used in this implementation.
+ */
+export interface VRMHumanLimit {
+    useDefaultValues?: boolean;
+    min?: THREE.Vector3;
+    max?: THREE.Vector3;
+    center?: THREE.Vector3;
+    axisLength?: number;
+}

package/types/humanoid/VRMHumanoid.d.ts

@@ -1,87 +1,87 @@
-import { GLTFNode, VRMPose, VRMSchema } from '../types';
-import { VRMHumanBone } from './VRMHumanBone';
-import { VRMHumanBoneArray } from './VRMHumanBoneArray';
-import { VRMHumanBones } from './VRMHumanBones';
-import { VRMHumanDescription } from './VRMHumanDescription';
-/**
- * A class represents humanoid of a VRM.
- */
-export declare class VRMHumanoid {
-    /**
-     * A [[VRMHumanBones]] that contains all the human bones of the VRM.
-     * You might want to get these bones using [[VRMHumanoid.getBone]].
-     */
-    readonly humanBones: VRMHumanBones;
-    /**
-     * A [[VRMHumanDescription]] that represents properties of the humanoid.
-     */
-    readonly humanDescription: VRMHumanDescription;
-    /**
-     * A [[VRMPose]] that is its default state.
-     * Note that it's not compatible with `setPose` and `getPose`, since it contains non-relative values of each local transforms.
-     */
-    readonly restPose: VRMPose;
-    /**
-     * Create a new [[VRMHumanoid]].
-     * @param boneArray A [[VRMHumanBoneArray]] contains all the bones of the new humanoid
-     * @param humanDescription A [[VRMHumanDescription]] that represents properties of the new humanoid
-     */
-    constructor(boneArray: VRMHumanBoneArray, humanDescription: VRMHumanDescription);
-    /**
-     * Return the current pose of this humanoid as a [[VRMPose]].
-     *
-     * Each transform is a local transform relative from rest pose (T-pose).
-     */
-    getPose(): VRMPose;
-    /**
-     * Let the humanoid do a specified pose.
-     *
-     * Each transform have to be a local transform relative from rest pose (T-pose).
-     * You can pass what you got from {@link getPose}.
-     *
-     * @param poseObject A [[VRMPose]] that represents a single pose
-     */
-    setPose(poseObject: VRMPose): void;
-    /**
-     * Reset the humanoid to its rest pose.
-     */
-    resetPose(): void;
-    /**
-     * Return a bone bound to a specified [[HumanBone]], as a [[VRMHumanBone]].
-     *
-     * See also: [[VRMHumanoid.getBones]]
-     *
-     * @param name Name of the bone you want
-     */
-    getBone(name: VRMSchema.HumanoidBoneName): VRMHumanBone | undefined;
-    /**
-     * Return bones bound to a specified [[HumanBone]], as an array of [[VRMHumanBone]].
-     * If there are no bones bound to the specified HumanBone, it will return an empty array.
-     *
-     * See also: [[VRMHumanoid.getBone]]
-     *
-     * @param name Name of the bone you want
-     */
-    getBones(name: VRMSchema.HumanoidBoneName): VRMHumanBone[];
-    /**
-     * Return a bone bound to a specified [[HumanBone]], as a THREE.Object3D.
-     *
-     * See also: [[VRMHumanoid.getBoneNodes]]
-     *
-     * @param name Name of the bone you want
-     */
-    getBoneNode(name: VRMSchema.HumanoidBoneName): GLTFNode | null;
-    /**
-     * Return bones bound to a specified [[HumanBone]], as an array of THREE.Object3D.
-     * If there are no bones bound to the specified HumanBone, it will return an empty array.
-     *
-     * See also: [[VRMHumanoid.getBoneNode]]
-     *
-     * @param name Name of the bone you want
-     */
-    getBoneNodes(name: VRMSchema.HumanoidBoneName): GLTFNode[];
-    /**
-     * Prepare a [[VRMHumanBones]] from a [[VRMHumanBoneArray]].
-     */
-    private _createHumanBones;
-}
+import { GLTFNode, VRMPose, VRMSchema } from '../types';
+import { VRMHumanBone } from './VRMHumanBone';
+import { VRMHumanBoneArray } from './VRMHumanBoneArray';
+import { VRMHumanBones } from './VRMHumanBones';
+import { VRMHumanDescription } from './VRMHumanDescription';
+/**
+ * A class represents humanoid of a VRM.
+ */
+export declare class VRMHumanoid {
+    /**
+     * A [[VRMHumanBones]] that contains all the human bones of the VRM.
+     * You might want to get these bones using [[VRMHumanoid.getBone]].
+     */
+    readonly humanBones: VRMHumanBones;
+    /**
+     * A [[VRMHumanDescription]] that represents properties of the humanoid.
+     */
+    readonly humanDescription: VRMHumanDescription;
+    /**
+     * A [[VRMPose]] that is its default state.
+     * Note that it's not compatible with `setPose` and `getPose`, since it contains non-relative values of each local transforms.
+     */
+    readonly restPose: VRMPose;
+    /**
+     * Create a new [[VRMHumanoid]].
+     * @param boneArray A [[VRMHumanBoneArray]] contains all the bones of the new humanoid
+     * @param humanDescription A [[VRMHumanDescription]] that represents properties of the new humanoid
+     */
+    constructor(boneArray: VRMHumanBoneArray, humanDescription: VRMHumanDescription);
+    /**
+     * Return the current pose of this humanoid as a [[VRMPose]].
+     *
+     * Each transform is a local transform relative from rest pose (T-pose).
+     */
+    getPose(): VRMPose;
+    /**
+     * Let the humanoid do a specified pose.
+     *
+     * Each transform have to be a local transform relative from rest pose (T-pose).
+     * You can pass what you got from {@link getPose}.
+     *
+     * @param poseObject A [[VRMPose]] that represents a single pose
+     */
+    setPose(poseObject: VRMPose): void;
+    /**
+     * Reset the humanoid to its rest pose.
+     */
+    resetPose(): void;
+    /**
+     * Return a bone bound to a specified [[HumanBone]], as a [[VRMHumanBone]].
+     *
+     * See also: [[VRMHumanoid.getBones]]
+     *
+     * @param name Name of the bone you want
+     */
+    getBone(name: VRMSchema.HumanoidBoneName): VRMHumanBone | undefined;
+    /**
+     * Return bones bound to a specified [[HumanBone]], as an array of [[VRMHumanBone]].
+     * If there are no bones bound to the specified HumanBone, it will return an empty array.
+     *
+     * See also: [[VRMHumanoid.getBone]]
+     *
+     * @param name Name of the bone you want
+     */
+    getBones(name: VRMSchema.HumanoidBoneName): VRMHumanBone[];
+    /**
+     * Return a bone bound to a specified [[HumanBone]], as a THREE.Object3D.
+     *
+     * See also: [[VRMHumanoid.getBoneNodes]]
+     *
+     * @param name Name of the bone you want
+     */
+    getBoneNode(name: VRMSchema.HumanoidBoneName): GLTFNode | null;
+    /**
+     * Return bones bound to a specified [[HumanBone]], as an array of THREE.Object3D.
+     * If there are no bones bound to the specified HumanBone, it will return an empty array.
+     *
+     * See also: [[VRMHumanoid.getBoneNode]]
+     *
+     * @param name Name of the bone you want
+     */
+    getBoneNodes(name: VRMSchema.HumanoidBoneName): GLTFNode[];
+    /**
+     * Prepare a [[VRMHumanBones]] from a [[VRMHumanBoneArray]].
+     */
+    private _createHumanBones;
+}

package/types/humanoid/VRMHumanoidImporter.d.ts

@@ -1,13 +1,13 @@
-import { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
-import { VRMHumanoid } from './VRMHumanoid';
-/**
- * An importer that imports a [[VRMHumanoid]] from a VRM extension of a GLTF.
- */
-export declare class VRMHumanoidImporter {
-    /**
-     * Import a [[VRMHumanoid]] from a VRM.
-     *
-     * @param gltf A parsed result of GLTF taken from GLTFLoader
-     */
-    import(gltf: GLTF): Promise<VRMHumanoid | null>;
-}
+import { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
+import { VRMHumanoid } from './VRMHumanoid';
+/**
+ * An importer that imports a [[VRMHumanoid]] from a VRM extension of a GLTF.
+ */
+export declare class VRMHumanoidImporter {
+    /**
+     * Import a [[VRMHumanoid]] from a VRM.
+     *
+     * @param gltf A parsed result of GLTF taken from GLTFLoader
+     */
+    import(gltf: GLTF): Promise<VRMHumanoid | null>;
+}

package/types/humanoid/index.d.ts

@@ -1,6 +1,6 @@
-export * from './VRMHumanBone';
-export * from './VRMHumanBones';
-export * from './VRMHumanDescription';
-export * from './VRMHumanLimit';
-export * from './VRMHumanoid';
-export * from './VRMHumanoidImporter';
+export * from './VRMHumanBone';
+export * from './VRMHumanBones';
+export * from './VRMHumanDescription';
+export * from './VRMHumanLimit';
+export * from './VRMHumanoid';
+export * from './VRMHumanoidImporter';

package/types/index.d.ts

@@ -1,12 +1,12 @@
-export * from './VRM';
-export * from './VRMImporter';
-export * from './VRMUtils';
-export * from './blendshape';
-export * from './debug';
-export * from './firstperson';
-export * from './humanoid';
-export * from './lookat';
-export * from './springbone';
-export * from './types';
-export * from './material';
-export * from './meta';
+export * from './VRM';
+export * from './VRMImporter';
+export * from './VRMUtils';
+export * from './blendshape';
+export * from './debug';
+export * from './firstperson';
+export * from './humanoid';
+export * from './lookat';
+export * from './springbone';
+export * from './types';
+export * from './material';
+export * from './meta';

package/types/lookat/VRMCurveMapper.d.ts

@@ -1,36 +1,36 @@
-/**
- * This is an equivalent of CurveMapper class defined in UniVRM.
- * Will be used for [[VRMLookAtApplyer]]s, to define behavior of LookAt.
- *
- * See: https://github.com/vrm-c/UniVRM/blob/master/Assets/VRM/UniVRM/Scripts/LookAt/CurveMapper.cs
- */
-export declare class VRMCurveMapper {
-    /**
-     * An array represents the curve. See AnimationCurve class of Unity for its details.
-     *
-     * See: https://docs.unity3d.com/ja/current/ScriptReference/AnimationCurve.html
-     */
-    curve: number[];
-    /**
-     * The maximum input range of the [[VRMCurveMapper]].
-     */
-    curveXRangeDegree: number;
-    /**
-     * The maximum output value of the [[VRMCurveMapper]].
-     */
-    curveYRangeDegree: number;
-    /**
-     * Create a new [[VRMCurveMapper]].
-     *
-     * @param xRange The maximum input range
-     * @param yRange The maximum output value
-     * @param curve An array represents the curve
-     */
-    constructor(xRange?: number, yRange?: number, curve?: number[]);
-    /**
-     * Evaluate an input value and output a mapped value.
-     *
-     * @param src The input value
-     */
-    map(src: number): number;
-}
+/**
+ * This is an equivalent of CurveMapper class defined in UniVRM.
+ * Will be used for [[VRMLookAtApplyer]]s, to define behavior of LookAt.
+ *
+ * See: https://github.com/vrm-c/UniVRM/blob/master/Assets/VRM/UniVRM/Scripts/LookAt/CurveMapper.cs
+ */
+export declare class VRMCurveMapper {
+    /**
+     * An array represents the curve. See AnimationCurve class of Unity for its details.
+     *
+     * See: https://docs.unity3d.com/ja/current/ScriptReference/AnimationCurve.html
+     */
+    curve: number[];
+    /**
+     * The maximum input range of the [[VRMCurveMapper]].
+     */
+    curveXRangeDegree: number;
+    /**
+     * The maximum output value of the [[VRMCurveMapper]].
+     */
+    curveYRangeDegree: number;
+    /**
+     * Create a new [[VRMCurveMapper]].
+     *
+     * @param xRange The maximum input range
+     * @param yRange The maximum output value
+     * @param curve An array represents the curve
+     */
+    constructor(xRange?: number, yRange?: number, curve?: number[]);
+    /**
+     * Evaluate an input value and output a mapped value.
+     *
+     * @param src The input value
+     */
+    map(src: number): number;
+}

package/types/lookat/VRMLookAtApplyer.d.ts

@@ -1,18 +1,18 @@
-import * as THREE from 'three';
-import { VRMSchema } from '../types';
-/**
- * This class is used by [[VRMLookAtHead]], applies look at direction.
- * There are currently two variant of applier: [[VRMLookAtBoneApplyer]] and [[VRMLookAtBlendShapeApplyer]].
- */
-export declare abstract class VRMLookAtApplyer {
-    /**
-     * It represents its type of applier.
-     */
-    abstract readonly type: VRMSchema.FirstPersonLookAtTypeName;
-    /**
-     * Apply look at direction to its associated VRM model.
-     *
-     * @param euler `THREE.Euler` object that represents the look at direction
-     */
-    abstract lookAt(euler: THREE.Euler): void;
-}
+import * as THREE from 'three';
+import { VRMSchema } from '../types';
+/**
+ * This class is used by [[VRMLookAtHead]], applies look at direction.
+ * There are currently two variant of applier: [[VRMLookAtBoneApplyer]] and [[VRMLookAtBlendShapeApplyer]].
+ */
+export declare abstract class VRMLookAtApplyer {
+    /**
+     * It represents its type of applier.
+     */
+    abstract readonly type: VRMSchema.FirstPersonLookAtTypeName;
+    /**
+     * Apply look at direction to its associated VRM model.
+     *
+     * @param euler `THREE.Euler` object that represents the look at direction
+     */
+    abstract lookAt(euler: THREE.Euler): void;
+}

package/types/lookat/VRMLookAtBlendShapeApplyer.d.ts

@@ -1,26 +1,26 @@
-import * as THREE from 'three';
-import { VRMBlendShapeProxy } from '../blendshape';
-import { VRMSchema } from '../types';
-import { VRMCurveMapper } from './VRMCurveMapper';
-import { VRMLookAtApplyer } from './VRMLookAtApplyer';
-/**
- * This class is used by [[VRMLookAtHead]], applies look at direction to eye blend shapes of a VRM.
- */
-export declare class VRMLookAtBlendShapeApplyer extends VRMLookAtApplyer {
-    readonly type = VRMSchema.FirstPersonLookAtTypeName.BlendShape;
-    private readonly _curveHorizontal;
-    private readonly _curveVerticalDown;
-    private readonly _curveVerticalUp;
-    private readonly _blendShapeProxy;
-    /**
-     * Create a new VRMLookAtBlendShapeApplyer.
-     *
-     * @param blendShapeProxy A [[VRMBlendShapeProxy]] used by this applier
-     * @param curveHorizontal A [[VRMCurveMapper]] used for transverse direction
-     * @param curveVerticalDown A [[VRMCurveMapper]] used for down direction
-     * @param curveVerticalUp A [[VRMCurveMapper]] used for up direction
-     */
-    constructor(blendShapeProxy: VRMBlendShapeProxy, curveHorizontal: VRMCurveMapper, curveVerticalDown: VRMCurveMapper, curveVerticalUp: VRMCurveMapper);
-    name(): VRMSchema.FirstPersonLookAtTypeName;
-    lookAt(euler: THREE.Euler): void;
-}
+import * as THREE from 'three';
+import { VRMBlendShapeProxy } from '../blendshape';
+import { VRMSchema } from '../types';
+import { VRMCurveMapper } from './VRMCurveMapper';
+import { VRMLookAtApplyer } from './VRMLookAtApplyer';
+/**
+ * This class is used by [[VRMLookAtHead]], applies look at direction to eye blend shapes of a VRM.
+ */
+export declare class VRMLookAtBlendShapeApplyer extends VRMLookAtApplyer {
+    readonly type = VRMSchema.FirstPersonLookAtTypeName.BlendShape;
+    private readonly _curveHorizontal;
+    private readonly _curveVerticalDown;
+    private readonly _curveVerticalUp;
+    private readonly _blendShapeProxy;
+    /**
+     * Create a new VRMLookAtBlendShapeApplyer.
+     *
+     * @param blendShapeProxy A [[VRMBlendShapeProxy]] used by this applier
+     * @param curveHorizontal A [[VRMCurveMapper]] used for transverse direction
+     * @param curveVerticalDown A [[VRMCurveMapper]] used for down direction
+     * @param curveVerticalUp A [[VRMCurveMapper]] used for up direction
+     */
+    constructor(blendShapeProxy: VRMBlendShapeProxy, curveHorizontal: VRMCurveMapper, curveVerticalDown: VRMCurveMapper, curveVerticalUp: VRMCurveMapper);
+    name(): VRMSchema.FirstPersonLookAtTypeName;
+    lookAt(euler: THREE.Euler): void;
+}

package/types/lookat/VRMLookAtBoneApplyer.d.ts

@@ -1,28 +1,28 @@
-import * as THREE from 'three';
-import { VRMHumanoid } from '../humanoid';
-import { VRMSchema } from '../types';
-import { VRMCurveMapper } from './VRMCurveMapper';
-import { VRMLookAtApplyer } from './VRMLookAtApplyer';
-/**
- * This class is used by [[VRMLookAtHead]], applies look at direction to eye bones of a VRM.
- */
-export declare class VRMLookAtBoneApplyer extends VRMLookAtApplyer {
-    readonly type = VRMSchema.FirstPersonLookAtTypeName.Bone;
-    private readonly _curveHorizontalInner;
-    private readonly _curveHorizontalOuter;
-    private readonly _curveVerticalDown;
-    private readonly _curveVerticalUp;
-    private readonly _leftEye;
-    private readonly _rightEye;
-    /**
-     * Create a new VRMLookAtBoneApplyer.
-     *
-     * @param humanoid A [[VRMHumanoid]] used by this applier
-     * @param curveHorizontalInner A [[VRMCurveMapper]] used for inner transverse direction
-     * @param curveHorizontalOuter A [[VRMCurveMapper]] used for outer transverse direction
-     * @param curveVerticalDown A [[VRMCurveMapper]] used for down direction
-     * @param curveVerticalUp A [[VRMCurveMapper]] used for up direction
-     */
-    constructor(humanoid: VRMHumanoid, curveHorizontalInner: VRMCurveMapper, curveHorizontalOuter: VRMCurveMapper, curveVerticalDown: VRMCurveMapper, curveVerticalUp: VRMCurveMapper);
-    lookAt(euler: THREE.Euler): void;
-}
+import * as THREE from 'three';
+import { VRMHumanoid } from '../humanoid';
+import { VRMSchema } from '../types';
+import { VRMCurveMapper } from './VRMCurveMapper';
+import { VRMLookAtApplyer } from './VRMLookAtApplyer';
+/**
+ * This class is used by [[VRMLookAtHead]], applies look at direction to eye bones of a VRM.
+ */
+export declare class VRMLookAtBoneApplyer extends VRMLookAtApplyer {
+    readonly type = VRMSchema.FirstPersonLookAtTypeName.Bone;
+    private readonly _curveHorizontalInner;
+    private readonly _curveHorizontalOuter;
+    private readonly _curveVerticalDown;
+    private readonly _curveVerticalUp;
+    private readonly _leftEye;
+    private readonly _rightEye;
+    /**
+     * Create a new VRMLookAtBoneApplyer.
+     *
+     * @param humanoid A [[VRMHumanoid]] used by this applier
+     * @param curveHorizontalInner A [[VRMCurveMapper]] used for inner transverse direction
+     * @param curveHorizontalOuter A [[VRMCurveMapper]] used for outer transverse direction
+     * @param curveVerticalDown A [[VRMCurveMapper]] used for down direction
+     * @param curveVerticalUp A [[VRMCurveMapper]] used for up direction
+     */
+    constructor(humanoid: VRMHumanoid, curveHorizontalInner: VRMCurveMapper, curveHorizontalOuter: VRMCurveMapper, curveVerticalDown: VRMCurveMapper, curveVerticalUp: VRMCurveMapper);
+    lookAt(euler: THREE.Euler): void;
+}