import { BotAvatarSquashEase, BotAvatarState } from './types';
export declare const STATES: BotAvatarState[];
/** The jump's numbers: an idle flip's and a click's. */
export interface JumpConfig {
    /** how high, in body units (the body is 100 tall) */
    height: number;
    /** seconds in the air */
    time: number;
    /** how much the body stretches in the air, 0–2 */
    stretch: number;
    /** how much it squashes on the ground, before take-off and on landing, 0–2 */
    squash: number;
    /** seconds the landing squash takes, contact to recovered */
    squashTime: number;
    /** the landing squash's shape */
    squashEase: BotAvatarSquashEase;
    /** seconds the body holds its deepest squash on the ground */
    groundTime: number;
    /** how the weight settles through that hold */
    groundEase: BotAvatarSquashEase;
    /** seconds the body takes to rise from its deepest squash back to shape */
    riseTime: number;
    /** how it rises */
    riseEase: BotAvatarSquashEase;
    /** seconds a click's jump takes for its landing squash */
    clickSquashTime: number;
    /** whole turns in the air */
    spin: number;
    /** degrees of lean into it */
    lean: number;
    /** seconds between idle jumps, roughly (±40 %); 0 for none */
    every: number;
    /**
         when the landing squash begins: seconds before (negative) or after
        touch-down; 0 is the moment of contact
     */
    land: number;
}
export declare const JUMP_DEFAULTS: JumpConfig;
export interface Pose {
    /** radians; yaw > 0 turns the face to the viewer's right, pitch > 0 looks up */
    yaw: number;
    pitch: number;
    roll: number;
    /** body-box units (the 100×100 design space) */
    x: number;
    y: number;
    sx: number;
    sy: number;
    /** 0 shut … 1 open, before blinks */
    eyeOpen: number;
    /** how far each lid is down right now, 0 … 1 */
    blinkL: number;
    blinkR: number;
    lookX: number;
    lookY: number;
    /** the breathing cycle, −1 … 1 */
    breath: number;
    /** working only: how far the eyes have closed into a laugh, 0 … 1 */
    laugh: number;
    /**
         the cartoon whirl round a spinning body: strength 0 … 1, and where
        its head is, in radians round the ring
     */
    whirl: number;
    whirlAngle: number;
    /** blend weights: default, working, sleeping — they sum to 1 */
    w: [number, number, number];
}
export declare class Sim {
    readonly pose: Pose;
    state: BotAvatarState;
    private rand;
    private t;
    private wFrom;
    private tr;
    private trDuration;
    private yawW;
    private pitchW;
    private rollW;
    private lookXW;
    private lookYW;
    private blink;
    private blinkAt;
    private blinkAgain;
    private dart;
    private dartAt;
    private dartX;
    private dartY;
    private flip;
    private flipPoked;
    private jump;
    private flipAt;
    private flipSide;
    private nod;
    private nodAt;
    private hopPhase;
    private hopCount;
    /**
         the hops' gain: the working weight while in the state, then held so
        a hop under way finishes whole when the state is left
     */
    private hopGain;
    private laughEv;
    private laughAt;
    private prevYaw;
    private jelly;
    private jellyV;
    /** how far the eyes run ahead of a head turn */
    private gazeLead;
    /** the idle gaze: where the head is looking, and when it moves on */
    private gazeDir;
    private gazeAt;
    /** how far it turns to the side, 1 as the gaze has it */
    private turnK;
    /** the breathing cycle's phase, in turns */
    private breathPhase;
    private ptrX;
    private ptrY;
    private ptrS;
    private ptrTargetX;
    private ptrTargetY;
    private ptrTargetS;
    private baseYaw;
    constructor(seed: number, state?: BotAvatarState);
    setState(next: BotAvatarState, immediate?: boolean): void;
    /**
         Where the pointer is, relative to the head (−1 … 1 across a head
        width), and how strongly to follow it (0 lets go).
     */
    setPointer(x: number, y: number, strength: number): void;
    /** A hop and a full turn, right now, whatever the state. */
    poke(): void;
    /**
         How far the head turns to the side while idle: 1 as the gaze has
        it, 0 keeps it facing forward.
     */
    setTurn(k: number): void;
    /** The jump's numbers; any subset. */
    setJump(j: Partial<JumpConfig>): void;
    private nextGaze;
    /** when the next idle jump is due: `every` seconds, give or take 40 % */
    private nextFlip;
    /** Advance by `dt` seconds (already scaled by the speed). */
    update(dt: number): void;
}
/** The still pose of a state, for reduced motion and the first paint. */
export declare function restPose(state: BotAvatarState): Pose;