/**
GLTF 3D Avatar.
Once GLTF file is loaded, skeleton is inspected for existing arms, legs and head that can be animated.
Animation groups are also inspected and optionally modified.
Optional fixes can be applied to an avatar, typically position of an avatar, or changing the animation.
 */
export class HumanoidAvatar extends Avatar {
    static notFound: any[];
    static fixes: {};
    static findFixFile(fix: any): Promise<any>;
    /**
     * Create a HumanoidAvatar from given url. Does not load it though.
     */
    static createFromUrl(scene: any, url: any, shadowGenerator: any): Promise<HumanoidAvatar>;
    /**
    @param scene
    @param folder ServerFolder with the content
    @param shadowGenerator optional to cast shadows
     */
    constructor(scene: any, folder: any, shadowGenerator: any);
    /** ServerFolder with content path */
    folder: any;
    /** File name, default scene.gltf */
    file: any;
    /** Optional ShadowGenerator */
    shadowGenerator: any;
    /** Optional custom animations */
    animations: any;
    /** Height of the ground, default 0 */
    groundHeight: number;
    /** Object containing fixes */
    fixes: any;
    /** Wheter to generate animations for arms, legs and body (crouch/jump) movement, default true */
    generateAnimations: boolean;
    /** Return to rest after cloning, default true (otherwise keeps the pose)*/
    returnToRest: boolean;
    /** GLTF characters are facing the user when loaded, turn it around, default false.
     * Does not apply to cloned characters, only to the first one actually loaded.*/
    turnAround: boolean;
    /** Object containing author, license, source, title */
    info: any;
    /** Once the avatar is loaded an processed, body contains body parts, e.g. body.leftArm, body.rightLeg, body.neck */
    body: {};
    /** Contains the skeleton once the avatar is loaded and processed */
    skeleton: any;
    /** Parent mesh of the avatar, used for movement and attachment */
    parentMesh: any;
    /** Original root mesh of the avatar, used to scale the avatar */
    rootMesh: any;
    bonesTotal: number;
    bonesProcessed: any[];
    bonesDepth: number;
    character: any;
    activeAnimation: any;
    /** fetch API cache control - use no-cache in development */
    cache: string;
    /** Debug output, default false */
    debug: boolean;
    createBody(): void;
    neckQuat: any;
    neckQuatInv: any;
    headQuat: any;
    headQuatInv: any;
    log(anything: any): void;
    boneProcessed(bone: any): void;
    /**
     * Hide the avatar, also turns it around to prepare it for cloning. Used to keep reference to own avatar.
     * @param {boolean|undefined} forceTurn has to be turned the other way before cloning
     */
    hide(forceTurn: boolean | undefined): void;
    /**
     * Show the hidden avatar.
     */
    show(): void;
    /**
    Utility method, dispose of avatar and return this one.
    @param avatar optional avatar to dispose of
     */
    replace(avatar: any): this;
    hasCustomAnimations(): boolean;
    _processContainer(container: any, onSuccess: any): void;
    headPosition: any;
    skinnedMesh: any;
    baseRotation: any;
    initialHeadPos: any;
    /**
    Apply fixes after loading/instantiation
     */
    postProcess(): void;
    /**
    Load fixes from json file in the same folder, with the same name, and suffix .fixes.
    Called from load().
     */
    loadFixes(): Promise<void>;
    /**
    Disable nodes marked in fixes file
     */
    disableNodes(): void;
    /**
    Enable/disable given nodes
    @param nodeIds array of node identifiers
    @param enable true/false
     */
    enableNodes(nodeIds: any, enable: any): void;
    /**
    Slice an animation group
    @param group AnimationGroup to slice
    @param startTime slice starting time
    @param endTime slice ending time
    @returns new AnimationGroup containing slice of original animations
    */
    sliceGroup(group: any, startTime: any, endTime: any): any;
    /**
    Slice an animation
    @param animation Animation to slice
    @param start starting key
    @param end ending key
    @returns new Animation containing slice of original animation
    */
    sliceAnimation(animation: any, start: any, end: any): any;
    /**
    Returns all animation groups of this avatar.
    Applies fixes first, if any.
    */
    getAnimationGroups(animationGroups?: any): any;
    animationGroups: any;
    /** Returns file name of this avatar, consisting of folder name and scene file name */
    getUrl(): string;
    /**
    Loads the avatar.
    @param success callback to execute on success
    @param failure executed if loading fails
     */
    load(success: any, failure: any): void;
    instantiatedEntries: any;
    /** Returns head 'bone' */
    head(): any;
    /** Returns absolute position of the the head 'bone' */
    headPos(): any;
    /** Returns current height - distance head to feet */
    height(): number;
    /**
    Returns absolute value of vector, i.e. Math.abs() of every value
    @param vec Vector3 to get absolute
     */
    absVector(vec: any): any;
    /**
    Returns rounded value of vector, i.e. Math.round() of every value
    @param vec Vector3 to round
     */
    roundVector(vec: any): void;
    /**
    Look at given target. Head position is calculated without any bone limits.
    @param t target Vector3
     */
    lookAt(t: any): void;
    renderHeadRotation(quat: any): void;
    /** Debugging helper, draws a vector between given points */
    drawVector(from: any, to: any): void;
    /**
    Move given arm towards given target. Uses simplified 2-joint IK.
    @param arm arm to move
    @param t target position
     */
    reachFor(arm: any, t: any): any;
    /**
    Bend/stretch arm to a length
     */
    bendArm(arm: any, targetVector: any): boolean;
    /**
     * Move an arm or leg, optionally creates/updates arm animation depending on this.generateAnimations flag
     */
    renderLimbRotation(limb: any): void;
    _createLimbAnimation(name: any): any;
    _updateLimbAnimation(limb: any, anim: any, dest: any): void;
    legLength(): number;
    /**
    Set avatar position.
    @param pos postion
     */
    setPosition(pos: any): void;
    /**
    Set avatar rotation
    @param quat Quaternion
    */
    setRotation(quat: any): void;
    /**
    Sets the ground level
    @param y height of the ground at current position
     */
    groundLevel(y: any): void;
    /**
    Track user height: character may crouch or raise, or jump,
    depending on heights of avatar and user.
    @param height current user height
     */
    trackHeight(height: any): void;
    jumping: number;
    maxUserHeight: any;
    prevUserHeight: any;
    /**
    Moves the avatar to given height above the ground
    @param height jump how high
     */
    jump(height: any): void;
    /**
    Stand up straight, at the ground, legs fully stretched
     */
    standUp(): void;
    /**
    Rise a bit
    @param height rise how much
     */
    rise(height: any): void;
    /**
     * Renders crouch/raise changes to body: either generates the animation, or changes this.rootMesh position right away,
     * depending on this.generateAnimations flag.
     */
    renderBodyPosition(height: any): void;
    isBodyPositionChanging(): any;
    bodyTargetHeight(): number;
    /**
    Crouch a bit
    @param height how much
     */
    crouch(height: any): void;
    extractInitialLegTransformation(leg: any): void;
    /**
    Bend/stretch leg to a length
    @param leg
    @param length
     */
    bendLeg(leg: any, length: any): any;
    /**
    Returns lenght of an arm or leg, in absolute world coordinates.
    @param limb an arm or leg
    @returns total length of lower and upper arm/leg
     */
    calcLength(limb: any): void;
    /**
    Returns total weight of a vector, x+y+z
    @param vector Vector3 to sum
    */
    sum(vector: any): any;
    extractInitialArmTransformation(arm: any): void;
    /**
     * Point arm to given direction, in character space
     */
    armDirectionCharacter(arm: any, targetVector: any): any;
    /**
     * Point arm to given direction, in arm space
     */
    armDirectionLocal(arm: any, targetVector: any): any;
    setPose(pose: any): void;
    getAbsolutePosition(bone: any): any;
    /**
    Converts rotation quaternion of a node to euler angles
    @param node
    @returns Vector3 containing rotation around x,y,z
     */
    euler(node: any): any;
    degrees(node: any): any;
    /**
    Converts euler radians to degrees
    @param rot Vector3 rotation around x,y,z
    @returns Vector3 containing degrees around x,y,z
     */
    toDegrees(rot: any): any;
    countBones(bones: any): void;
    processBones(bones: any): void;
    isHipsName(boneName: any): any;
    processHips(bones: any): void;
    isLegName(boneName: any, lr: any, children: any): any;
    tryLeg(leg: any, bone: any): void;
    processLeg(leg: any, bone: any): void;
    processFoot(leg: any, bone: any): void;
    processSpine(bone: any): void;
    isArmName(boneName: any, lr: any): any;
    isArm(bone: any, boneName: any): boolean;
    hasChildren(bone: any): boolean;
    hasHeadAndShoulders(bone: any): boolean;
    isHeadOrShoulder(bone: any): any;
    processNeck(bone: any): void;
    headYAxisFix: number;
    headXAxisFix: number;
    headTarget: any;
    processArms(arm: any, bone: any): void;
    processFinger(finger: any, bone: any): void;
    /**
    Load an animation group from an url
     */
    loadAnimations(url: any, callback: any): void;
    /**
     * Enable or disable animation blending for all animation of all groups
     */
    animationBlending(enable?: boolean, speed?: number): void;
    /**
    Create an animation group from given object and attach it to the character.
     */
    attachAnimations(group: any): void;
    /**
    Saves all animations in given animation group.
    Opens save file dialog.
     */
    saveAnimations(groupName: any): void;
    /**
    Processes all animation in an animation group.
    @returns object suitable for saving
     */
    processAnimations(animationGroup: any): {
        name: any;
        animations: any[];
    };
    /**
     * Stop an animation. To allow for blending, just turns off looping rather than stopping it right away, unless forced.
     */
    stopAnimation(animationName: any, force?: boolean): void;
    getAnimation(animationName: any): any;
    /**
    Start a given animation
    @param animationName animation to start
    @param loop if set, changes AnimationGroup.loopAnimation property
    @param speedRatio if set, changes AnimationGroup.speedRatio
     */
    startAnimation(animationName: any, loop: any, speedRatio: any): void;
    /**
    Adds or remove all avatar meshes to given ShadowGenerator.
    @param shadowGenerator removes shadows if null
     */
    castShadows(shadowGenerator: any): void;
    /**
    After resizing and some other manipulations, matrices may need to be recomputed in a reliable way.
    How to do it depends on babylon.js version.
     */
    recompute(): void;
    /**
    Resize the avatar taking into account userHeight and headPos.
     */
    resize(): number;
    /** TODO Called when avatar size/height changes, supposed move name/text above the head, notify listeners */
    changed(): void;
    /** Avatar base class method */
    basePosition(): any;
    /** Avatar base class method */
    baseMesh(): any;
    /**
     * Handles animation change network event
     */
    animationChanged(obj: any, node: any): void;
    /**
     * Handles arm position change network event
     */
    leftArmPosChanged(obj: any, node: any): void;
    /**
     * Handles arm position change network event
     */
    rightArmPosChanged(obj: any, node: any): void;
    /**
     * Handles arm rotation change network event
     */
    leftArmRotChanged(obj: any, node: any): void;
    /**
     * Handles arm rotation change network event
     */
    rightArmRotChanged(obj: any, node: any): void;
    /**
     * Handles rotation change network event (quaternion)
     */
    rotationChanged(obj: any, node: any): void;
}
import { Avatar } from './avatar.js';