/**
 * First-person camera + body controller. See DESIGN.md (sibling file) for
 * the goals, layered architecture, and tuning rationale.
 *
 * Lifecycle: only `config` is serialized. `intent`, `state`, `pose`,
 * `signals`, and `eyeEntity` are transient — rebuilt by the system on
 * link.
 *
 * @author Alex Goldring
 * @copyright Company Named Limited (c) 2026
 */
export class FirstPersonPlayerController {
    static typeName: string;
    config: FirstPersonPlayerControllerConfig;
    intent: FirstPersonIntent;
    state: FirstPersonState;
    pose: FirstPersonPose;
    signals: FirstPersonSignals;
    /**
     * Mastery layer — registry of {@link MasteryEvaluator}s and the
     * telemetry score they feed. Designers register evaluators here;
     * the controller's system queries them at each decision point.
     * Empty by default (no mastery effects unless the game adds them).
     * @type {MasterySet}
     */
    mastery: MasterySet;
    /**
     * Movement abilities (wall-run, mantle, slide, etc.). Empty by
     * default — base locomotion is unchanged unless the game adds
     * abilities here.
     * @type {AbilitySet}
     */
    abilities: AbilitySet;
    /**
     * ID of the entity carrying the eye Transform + Camera. Created by
     * the system on link if -1. Held as a plain number rather than
     * EntityReference to keep serialization simple — the relationship
     * is rebuilt on link anyway.
     * @type {number}
     */
    eyeEntity: number;
    toJSON(): {
        config: {
            body: {
                height: number;
                crouchHeight: number;
                proneHeight: number;
                radius: number;
                mass: number;
                referenceMass: number;
                massCouplingStrength: number;
            };
            motion: {
                walkSpeed: number;
                sprintSpeed: number;
                crouchSpeed: number;
                airControl: number;
                groundAccelHalfLife: number;
                groundDecel: number;
                airAccel: number;
                backwardSpeedFactor: number;
                backwardAccelFactor: number;
            };
            jump: {
                anticipation: {
                    duration: number;
                    dipAmount: number;
                };
                peakHeight: number;
                timeToApex: number;
                coyoteTime: number;
                bufferTime: number;
                fallGravityMult: number;
                cutGravityMult: number;
            };
            landing: {
                recovery: {
                    spring: {
                        halfLife: number;
                        zeta: number;
                    };
                    dipPerVy: number;
                    dipMax: number;
                };
                softThreshold: number;
                hardThreshold: number;
            };
            crouch: {
                transitionTime: number;
                mode: string;
            };
            ledgeGrab: {
                hangOffsetY: number;
                hangOffsetForward: number;
                exertionRiseRate: number;
                minAirborneTime: number;
                mantleUpUpFactor: number;
            };
            mantle: {
                minHeight: number;
                maxHeight: number;
                duration: number;
                forwardOffsetOnLand: number;
            };
            wallRun: {
                minSpeed: number;
                minAirborneTime: number;
                maxDuration: number;
                gravityFactor: number;
                cameraRollDeg: number;
            };
            wallJump: {
                outwardImpulse: number;
                upFactor: number;
                nearWallMaxDistance: number;
            };
            slide: {
                minEntrySpeed: number;
                endSpeed: number;
                friction: number;
                startupWindow: number;
                slideJumpUpFactor: number;
                entryImpactVelocity: number;
            };
            bob: {
                stepFreqAtWalk: number;
                stepFreqExp: number;
                verticalAmpAtWalk: number;
                lateralAmpAtWalk: number;
                ampMassScale: number;
                rollAtWalkDeg: number;
                minStepSpeed: number;
                intensityHalfLife: number;
                impactSpringHalfLife: number;
                impactSpringZeta: number;
                impactKickMultiplier: number;
                backwardVerticalAmpFactor: number;
                backwardLateralAmpFactor: number;
                backwardRollFactor: number;
                leanCouplingFactor: number;
            };
            breath: {
                rateRestHz: number;
                rateMaxHz: number;
                amplitudeRestM: number;
                amplitudeMaxM: number;
                pitchAmpRestDeg: number;
                pitchAmpMaxDeg: number;
                noiseAmount: number;
                locomotorCouplingMax: number;
                couplingMinStrideFreqHz: number;
            };
            exertion: {
                sprintRiseRate: number;
                idleDecayRate: number;
                jumpRise: number;
                crouchEnterRise: number;
                landImpulsePerVy: number;
                landImpulseMax: number;
                rateDecayHalfLife: number;
                ampDecayHalfLife: number;
                bobLateralBoostAtMax: number;
                headDroopAtMaxDeg: number;
                headDroopHalfLife: number;
            };
            lean: {
                spring: {
                    halfLife: number;
                    zeta: number;
                };
                enabled: boolean;
                maxRollDeg: number;
                lookLeanEnabled: boolean;
                lookLeanDegPerRadPerSec: number;
                lookLeanYawRateClamp: number;
                crouchLookLeanFactor: number;
            };
            fov: {
                base: number;
                sprintAdd: number;
                crouchAdd: number;
                smoothHalfLife: number;
            };
            look: {
                pitchMinDeg: number;
                pitchMaxDeg: number;
                invertY: boolean;
            };
            posture: {
                sprintForwardPitchDeg: number;
                sprintForwardPitchHalfLife: number;
                sprintForwardShiftM: number;
            };
            gravity: {
                magnitude: number;
            };
        };
    };
    fromJSON(json: any): void;
    /**
     * @param {FirstPersonPlayerController} other
     */
    copy(other: FirstPersonPlayerController): void;
    clone(): FirstPersonPlayerController;
    equals(other: any): boolean;
    hash(): number;
}
export namespace FirstPersonPlayerController {
    export { FirstPersonActionState as ActionState };
    export { FirstPersonLocomotionMode as LocomotionMode };
}
import { FirstPersonPlayerControllerConfig } from "./FirstPersonPlayerControllerConfig.js";
/**
 * Intent — what the player (or AI) wants the body to do. All fields are
 * latched ("hold-state") except `look`, which accumulates deltas between
 * fixed updates and is zeroed by the system on consume.
 *
 * The system performs its own edge detection on `jump` (and on `crouch`
 * when toggle-mode is configured). This is what guarantees a held jump
 * button does not produce repeated jumps.
 */
declare class FirstPersonIntent {
    /** [-1..1, -1..1] forward+/right+ in body-local. @type {Vector2} */
    move: Vector2;
    /**
     * Accumulated look delta (radians). x = yaw, y = pitch. Consumed and
     * zeroed by the system in fixedUpdate.
     * @type {Vector2}
     */
    look: Vector2;
    /** Hold state — true while jump button is held. @type {boolean} */
    jump: boolean;
    /** Hold state — meaning depends on config.crouch.mode. @type {boolean} */
    crouch: boolean;
    /** Hold state — true while sprint button is held. @type {boolean} */
    sprint: boolean;
}
/**
 * Derived state — read-only outputs. Useful for HUDs, sound systems, AI
 * sensors that need to know "is the player crouched / sprinting / etc."
 */
declare class FirstPersonState {
    grounded: boolean;
    timeSinceGrounded: number;
    /** Set by the physics layer (or the prototype's flat-ground integrator). */
    groundNormal: Vector3;
    surfaceTag: any;
    speed: number;
    /** [0..1] vs sprint speed — drives bob amp and FOV kick. */
    speedNormalized: number;
    /** Horizontal locomotion mode. See {@link FirstPersonLocomotionMode}. */
    locomotionMode: number;
    verticalSpeed: number;
    airborneTime: number;
    fallDistance: number;
    jumpBufferRemaining: number;
    inJumpAnticipation: boolean;
    isVariableJumpCut: boolean;
    /** Set to true while jumping ascent until apex; gates the cut behavior. */
    isAscending: boolean;
    exertion: number;
    breathPhase: number;
    breathRateHz: number;
    breathAmplitudeM: number;
    stridePhase: number;
    stepCount: number;
    /** Which foot fires next: 0 = right, 1 = left. */
    nextFoot: number;
    eyeHeight: number;
    /** Set true when crouch was released but a ceiling above prevents standing. */
    crouchBlocked: boolean;
    /** True while in crouch pose (independent of intent — see crouchBlocked). */
    crouchActive: boolean;
    /**
     * Body posture. Set each tick by whichever layer owns motion: the
     * base derives Stand/Crouch from intent; an active ability can
     * force Prone (slide) or Hang (ledge-grab). See
     * {@link FirstPersonPosture}. Drives eye-height target and gait
     * gating (stride, footsteps, bob).
     * @type {number}
     */
    posture: number;
    leanRollRad: number;
}
import { FirstPersonPose } from "./pose/FirstPersonPose.js";
/**
 * Event surface. All signals are sent from fixedUpdate so listeners see
 * consistent state across the same simulation tick.
 */
declare class FirstPersonSignals {
    /** {side:"L"|"R", speed:number, surfaceTag:string?} */
    onFootStep: Signal<any, any, any, any, any, any, any, any>;
    /** {peakHeight:number} fired at impulse, after anticipation finishes. */
    onJumpStart: Signal<any, any, any, any, any, any, any, any>;
    /** No payload. */
    onJumpApex: Signal<any, any, any, any, any, any, any, any>;
    /** {reason:"jump"|"fall"} */
    onLeaveGround: Signal<any, any, any, any, any, any, any, any>;
    /** {verticalSpeed:number, kind:"soft"|"hard"} */
    onLand: Signal<any, any, any, any, any, any, any, any>;
    onCrouchEnter: Signal<any, any, any, any, any, any, any, any>;
    onCrouchExit: Signal<any, any, any, any, any, any, any, any>;
    onSprintStart: Signal<any, any, any, any, any, any, any, any>;
    onSprintStop: Signal<any, any, any, any, any, any, any, any>;
    /** {amplitude:number, rateHz:number} fired at peak inhale (phase 0.25). */
    onBreathIn: Signal<any, any, any, any, any, any, any, any>;
    /** {amplitude:number, rateHz:number} fired at peak exhale (phase 0.75). */
    onBreathOut: Signal<any, any, any, any, any, any, any, any>;
    /** {ledgeHeight:number} — fired when LedgeGrab activates. */
    onLedgeGrab: Signal<any, any, any, any, any, any, any, any>;
    /** {reason:"mantle-up"|"drop"|"slip"|"shuffle-off"} */
    onLedgeRelease: Signal<any, any, any, any, any, any, any, any>;
}
import { MasterySet } from "./mastery/MasterySet.js";
import { AbilitySet } from "./abilities/AbilitySet.js";
import { FirstPersonActionState } from "./pose/FirstPersonPose.js";
import { FirstPersonLocomotionMode } from "./pose/FirstPersonPose.js";
import Vector2 from "../../../core/geom/Vector2.js";
import Vector3 from "../../../core/geom/Vector3.js";
import Signal from "../../../core/events/signal/Signal.js";
export {};
//# sourceMappingURL=FirstPersonPlayerController.d.ts.map