@babylonjs-toolkit/next 9.30.0 → 9.34.0

package/lib/project.d.ts

@@ -1,9 +1,2169 @@
 import type * as BABYLON from "@babylonjs/core/Legacy/legacy";
 declare const BABYLON: any;
-import { ScriptComponent, IUnityVector3, IUnityVector4, AudioSource, RigidbodyPhysics, RaycastVehicle, btWheelInfo, PlayerNumber, CustomShaderMaterial, CustomShaderMaterialPlugin, PreloadAssetsManager, IAssetPreloader } from './scenemanager';
+import { ScriptComponent, Animator, RigidbodyPhysics, CustomShaderMaterial, AudioSource, ShurikenParticles, IParticleMainModule, IParticleMinMaxCurve, IUnityVector3, IUnityVector4, RaycastVehicle, btWheelInfo, PlayerNumber, CustomShaderMaterialPlugin, PreloadAssetsManager, IAssetPreloader, CharacterController } from './scenemanager';
 import { LocalMessageBus } from './localmessagebus';
 import { NoiseFunction2D } from './noisefunction2d';
 import { TouchJoystickHandler } from './touchjoystickhandler';
+export declare class KartBumpTarget extends ScriptComponent {
+    hasStar: boolean;
+    isAutoDriving: boolean;
+    slotIndex: number;
+    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+}
+export declare const DRIVER_LEAN_INPUT_THRESHOLD: number;
+export declare const DRIVER_LEAN_PATH_ERROR_THRESHOLD: number;
+export declare const DRIVER_STEERING_WHEEL_ANGLE: number;
+export declare const DRIVER_STEERING_WHEEL_RATE: number;
+export declare const DRIVER_STEERING_WHEEL_PATH_ERROR_THRESHOLD: number;
+export declare const DRIVER_STEERING_WHEEL_PATH_RATE: number;
+export declare const DRIVER_HEAD_LOOK_RANGE: number;
+export declare const DRIVER_HEAD_LOOK_RATE: number;
+export declare const DRIVER_HEAD_RETURN_RATE: number;
+export declare const DRIVER_HEAD_LOOK_CYCLE_SECONDS: number;
+export declare const DRIVER_HEAD_LOOK_DELAY_SECONDS: number;
+export declare const DRIVER_HEAD_LOOK_START_SECONDS: number;
+export declare const DRIVER_HEAD_LOOK_MAX_DEGREES: number;
+export declare const DRIVER_HEAD_LOOK_MIN_SPEED: number;
+export declare const DRIVER_HEAD_WRITE_EPSILON: number;
+export declare const DRIVER_IDLE_OR_STEERING_STATES: string[];
+export declare const DRIVER_TURN_LEFT_PARAMETER: string;
+export declare const DRIVER_TURN_RIGHT_PARAMETER: string;
+export declare const DRIVER_HAS_ITEM_PARAMETER: string;
+export declare const DRIVER_REVERSE_PARAMETER: string;
+export interface IDriverLeanState {
+    turnLeft: boolean;
+    turnRight: boolean;
+}
+export interface IDriverAnimationFrame {
+    steeringInput: number;
+    antiGravity: boolean;
+    speed: number;
+    raceStarted: boolean;
+    raceCompleted: boolean;
+    hasHeldItem: boolean;
+    reversing: boolean;
+}
+export declare class KartDriverAnimation {
+    private static readonly KART_ROOTS;
+    private readonly kartRoot;
+    private readonly driverAnimator;
+    private readonly headNode;
+    private pathError;
+    private steeringWheelDegrees;
+    private headYawDegrees;
+    private lookCycleSeconds;
+    private readonly headBaseRotation;
+    private readonly headWrittenRotation;
+    private hasWrittenHead;
+    private reverseWritten;
+    private readonly lookRotation;
+    private readonly localAxis;
+    private readonly inverseKartMatrix;
+    private readonly inverseParentMatrix;
+    private readonly opponentLocal;
+    constructor(kartRoot: BABYLON.TransformNode, driverAnimator: Animator | null, headNode: BABYLON.TransformNode | null);
+    static leanFromInput(steeringInput: number): IDriverLeanState;
+    static leanFromPathError(pathError: number): IDriverLeanState;
+    static leanForFrame(frame: IDriverAnimationFrame, pathError: number): IDriverLeanState;
+    static steeringWheelTarget(steeringInput: number, antiGravity: boolean, currentDegrees: number): number;
+    static steeringWheelTargetFromPathError(pathError: number, antiGravity: boolean, currentDegrees: number): number;
+    static headYawTarget(localRight: number, localForward: number): number;
+    static advanceLookCycle(cycleSeconds: number, deltaSeconds: number): number;
+    setPathError(pathError: number): void;
+    updateFrame(frame: IDriverAnimationFrame, animators: Animator[], deltaSeconds: number): void;
+    private writeReverse;
+    applySteeringWheel(wheel: BABYLON.TransformNode | null, restRotation: BABYLON.Quaternion | null): void;
+    lateFrame(frame: IDriverAnimationFrame, deltaSeconds: number): void;
+    dispose(): void;
+    private steeringWheelTargetForFrame;
+    private isIdleOrSteering;
+    private nearestOpponentYaw;
+    private writeHead;
+}
+export declare enum EKartHitKind {
+    Banana = 0,
+    Shell = 1,
+    Explosion = 2
+}
+export declare class KartHitState {
+    static readonly SPIN_OUT_SECONDS: number;
+    static readonly HIT_INVULNERABLE_SECONDS: number;
+    static readonly STAR_SECONDS: number;
+    private spinOutRemaining;
+    private invulnerableRemaining;
+    private starRemaining;
+    private autoDriveActive;
+    private lastHitKind;
+    applyHit(kind: EKartHitKind): boolean;
+    startStar(seconds?: number): void;
+    setAutoDrive(active: boolean): void;
+    tick(deltaSeconds: number): void;
+    isSpunOut(): boolean;
+    isInvulnerable(): boolean;
+    hasStar(): boolean;
+    getStarRemaining(): number;
+    isAutoDriving(): boolean;
+    isImmune(): boolean;
+    getLastHitKind(): EKartHitKind | null;
+}
+export declare enum EKartContactKind {
+    Road = 0,
+    Step = 1,
+    Wall = 2
+}
+export interface IKartPush {
+    force: BABYLON.Vector3;
+    remainingSeconds: number;
+}
+export declare class KartImpacts {
+    static readonly GLANCE_MAX_INTO_WALL: number;
+    static readonly WALL_BOUNCE_MAX_SPEED: number;
+    static readonly WALL_BOUNCE_DECAY_RATE: number;
+    static readonly WALL_HEADING_EASE_SECONDS: number;
+    static readonly BUMP_FORCE_FAST: number;
+    static readonly BUMP_FORCE_SLOW: number;
+    static readonly BUMP_FAST_SPEED: number;
+    static readonly BUMP_PUSH_SECONDS: number;
+    static readonly BUMP_COOLDOWN_SECONDS: number;
+    static readonly BUMP_MAX_DISTANCE: number;
+    static readonly PUSH_DECAY_RATE: number;
+    static readonly ANTIGRAVITY_BUMP_BOOST_SECONDS: number;
+    static readonly ROAD_CONTACT_MIN_UP_DOT: number;
+    static readonly STEP_MIN_UP_DOT: number;
+    static readonly LEDGE_MOUNT_MAX_HEIGHT: number;
+    static readonly LEDGE_CORNER_MIN_INTO: number;
+    static readonly MOVING_ROAD_MIN_UP_DOT: number;
+    static readonly CONTACT_PRESS_SPEED: number;
+    static readonly CONTACT_TOUCH_DISTANCE: number;
+    private static readonly MIN_DIRECTION_LENGTH;
+    static sideOfContact(position: BABYLON.Vector3, forward: BABYLON.Vector3, up: BABYLON.Vector3, otherPosition: BABYLON.Vector3): number;
+    static speedAfterWallHit(currentSpeed: number, intoWall: number): number;
+    static intoWallFraction(travelDirection: BABYLON.Vector3, wallNormal: BABYLON.Vector3): number;
+    static wallBounceSpeed(intoWall: number): number;
+    static fadeWallBounce(bounceSpeed: number, stepSeconds: number): number;
+    static headingEaseYaw(localWallNormal: BABYLON.Vector3, travelSign: number, stepSeconds: number): number;
+    static registerMovingRoad(body: BABYLON.PhysicsBody): void;
+    static unregisterMovingRoad(body: BABYLON.PhysicsBody): void;
+    static isMovingRoad(body: BABYLON.PhysicsBody | null | undefined): boolean;
+    static classifyContact(contactNormal: BABYLON.Vector3, kartUp: BABYLON.Vector3, stepMinUpDot?: number, onMovingRoad?: boolean): EKartContactKind;
+    static ledgeHeight(contactNormal: BABYLON.Vector3, kartUp: BABYLON.Vector3, sphereRadius: number): number;
+    static isMountableLedgeCorner(contactNormal: BABYLON.Vector3, kartUp: BABYLON.Vector3, sphereRadius: number, travelDirection: BABYLON.Vector3): boolean;
+    static isNextStepOfStairs(blockerNormal: BABYLON.Vector3, kartUp: BABYLON.Vector3, sphereRadius: number, sweepClearance: number): boolean;
+    static ledgeMountMinUpDot(sphereRadius: number): number;
+    static isMountableStep(stepHeight: number, sphereRadius: number): boolean;
+    static slideNormal(contactNormal: BABYLON.Vector3, kartUp: BABYLON.Vector3, stepMinUpDot?: number, onMovingRoad?: boolean): BABYLON.Vector3 | null;
+    static removeVelocityIntoSurface(velocity: BABYLON.Vector3, surfaceNormal: BABYLON.Vector3): void;
+    static keepNoseSpeed(velocity: BABYLON.Vector3, forward: BABYLON.Vector3, noseSpeed: number): boolean;
+    static limitApproachSpeed(velocity: BABYLON.Vector3, surfaceNormal: BABYLON.Vector3, gapMeters: number, stepSeconds: number): void;
+    static wallAheadSlideNormal(hitNormal: BABYLON.Vector3, kartUp: BABYLON.Vector3, onMovingRoad?: boolean): BABYLON.Vector3 | null;
+    static steeringSpeed(realSpeed: number, decreedSpeed: number, heldByWall: boolean): number;
+    static createBumpPush(right: BABYLON.Vector3, side: number, currentSpeed: number, hasStar: boolean): IKartPush;
+    static stepPush(push: IKartPush, stepVelocity: BABYLON.Vector3, chassisMass: number, stepSeconds: number): boolean;
+    private static limitSpeedIntoSurface;
+}
+export declare class KartSurfaceContacts {
+    static readonly MAX_CONTACTS: number;
+    private static readonly SLIDE_PASSES;
+    private incoming;
+    private current;
+    private incomingIsWall;
+    private currentIsWall;
+    private incomingCount;
+    private currentCount;
+    private incomingWall;
+    private currentWall;
+    private incomingMovingRoad;
+    private currentMovingRoad;
+    add(contactNormal: BABYLON.Vector3, kartUp: BABYLON.Vector3, stepMinUpDot?: number, onMovingRoad?: boolean): void;
+    addMovingRoadContact(): void;
+    touchesMovingRoad(): boolean;
+    beginStep(): void;
+    touchesWall(): boolean;
+    count(): number;
+    strongestWall(travelDirection: BABYLON.Vector3, result: BABYLON.Vector3): number;
+    slide(velocity: BABYLON.Vector3): void;
+    clear(): void;
+}
+export declare const KART_FINISH_LINE_TAG: string;
+export declare const KART_STOP_DRIFT_ROT_SECONDS: number;
+export declare const KART_STOP_DRIFT_ROT_RATE: number;
+export declare const KART_CHECKPOINT_RESPAWN_LIFT: number;
+export interface IKartCheckpoint {
+    node: BABYLON.TransformNode;
+    position?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    respawnPosition?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    heading?: number;
+}
+export declare class KartLapCounter extends ScriptComponent {
+    LAPCOUNT: number;
+    currentCheckpointVal: number;
+    totalCheckpointVal: number;
+    checkpointsVisited: boolean[];
+    distanceToNextCheckpoint: number;
+    Position: number;
+    endPosition: number;
+    isPlayer: boolean;
+    finished: boolean;
+    finishTime: number;
+    finishOrder: number;
+    lapStartTime: number;
+    lapTimes: number[];
+    pendingFinish: boolean;
+    private finalLapAnnounced;
+    protected checkpoints: IKartCheckpoint[];
+    private finishLinePoint;
+    private readonly finishLineForward;
+    private finishLineResolved;
+    protected kart: any;
+    race: any;
+    protected awake(): void;
+    protected start(): void;
+    protected resolveKart(): any;
+    setCheckpoints(checkpoints: IKartCheckpoint[]): void;
+    getCheckpoints(): IKartCheckpoint[];
+    isLapDue(): boolean;
+    getDistancePastFinishLine(position: BABYLON.Vector3): number | null;
+    protected resolveFinishLine(): void;
+    private static distanceToSegment;
+    checkAllPoints(): boolean;
+    protected onTimingTrigger(other: BABYLON.TransformNode): void;
+    protected reportCountedLap(): void;
+    protected applyRespawnPoint(checkpoint: IKartCheckpoint): void;
+    protected checkpointPosition(checkpoint: IKartCheckpoint): BABYLON.Vector3;
+    protected checkpointRespawnPosition(checkpoint: IKartCheckpoint): BABYLON.Vector3;
+    protected checkpointRotation(checkpoint: IKartCheckpoint): BABYLON.Quaternion;
+    protected update(): void;
+    tick(dt: number): void;
+    protected checkForFinish(): void;
+    isStopDriftRotRunning(): boolean;
+    protected calculateDist(): void;
+    resetLaps(): void;
+}
+export declare class KartOutOfBounds extends ScriptComponent {
+    FellInWater: boolean;
+    outOfBounds: boolean;
+    PlayerBeingMoved: boolean;
+    private kart;
+    protected awake(): void;
+    protected start(): void;
+    protected update(): void;
+    private findKart;
+}
+export declare class KartPathSteering {
+    static readonly SMOOTH_TIME_SECONDS: number;
+    static readonly ORIGINAL_FRAME_RATE: number;
+    static directionError(position: BABYLON.Vector3, forward: BABYLON.Vector3, up: BABYLON.Vector3, target: BABYLON.Vector3): number;
+    static steeringFromError(smoothedError: number, turnSpeedDivider: number, kartYawRateDegreesPerSecond: number): number;
+    static lookAheadOnSegment(position: BABYLON.Vector3, segmentStart: BABYLON.Vector3, segmentEnd: BABYLON.Vector3, lookAheadMeters: number, result: BABYLON.Vector3): BABYLON.Vector3;
+    static smoothError(current: number, target: number, deltaSeconds: number): number;
+}
+export declare const COUNTDOWN_CLIP_SPEED: number;
+export declare enum EKartCountdownEvent {
+    Beep = 0,
+    Go = 1,
+    Start = 2
+}
+export interface IKartCountdownBeat {
+    kind: EKartCountdownEvent;
+    at: number;
+}
+export declare const KART_COUNTDOWN_BEATS: IKartCountdownBeat[];
+export declare const KART_COUNTDOWN_LENGTH: number;
+export declare const KART_POSITION_SORT_INTERVAL: number;
+export interface IKartRacerEntry {
+    lapCounter: KartLapCounter;
+    kart: StandardKartController;
+    isHuman: boolean;
+}
+export interface IKartRaceResult {
+    lapCounter: KartLapCounter;
+    kart: StandardKartController;
+    place: number;
+    finished: boolean;
+    finishTime: number;
+    isHuman: boolean;
+}
+export declare class KartRaceManager extends ScriptComponent {
+    static readonly RESULTS_DELAY_SECONDS: number;
+    static readonly RACE_STARTED_EVENT: string;
+    private static readonly RESULTS_DELAY_TOLERANCE;
+    RACE_STARTED: boolean;
+    RACE_COMPLETED: boolean;
+    countDownTime: number;
+    RaceTime: number;
+    MAXLAPS: number;
+    lapCounters: any[];
+    sortedRacers: any[];
+    onCountdownBeep: ((index: number) => void) | null;
+    onGoSound: (() => void) | null;
+    onRaceStart: (() => void) | null;
+    racers: IKartRacerEntry[];
+    onLapCompleted: ((lapCounter: KartLapCounter, completedLap: number) => void) | null;
+    onFinalLap: ((lapCounter: KartLapCounter) => void) | null;
+    onRacerFinished: ((lapCounter: KartLapCounter, place: number) => void) | null;
+    onResults: ((results: IKartRaceResult[]) => void) | null;
+    private countDownClockRunning;
+    private countdownBeat;
+    private sortTime;
+    private finishedCount;
+    private resultsDelayRunning;
+    private resultsDelayElapsed;
+    private resultsFired;
+    protected awake(): void;
+    startCountdown(): void;
+    isCountdownRunning(): boolean;
+    registerRacer(lapCounter: KartLapCounter, kart: StandardKartController, isHuman: boolean): void;
+    getTimeUntilGo(): number;
+    getCountdownBeat(): number;
+    getBeepCount(): number;
+    tick(dt: number): void;
+    getResults(): IKartRaceResult[];
+    private chargeLaunches;
+    private releaseRacers;
+    private resolvePendingFinishes;
+    private haveAllHumansFinished;
+    private tickResultsDelay;
+    private fireCountdownBeats;
+    private dispatchBeat;
+    calculateRacerPosition(): void;
+    getSortedRacers(): any[];
+    resetRace(): void;
+}
+export declare enum EKartRescueReason {
+    Water = 0,
+    OutOfBounds = 1,
+    Fall = 2,
+    Flipped = 3,
+    Wedged = 4,
+    OffCourse = 5
+}
+export interface IKartRescuePlacement {
+    position: BABYLON.Vector3;
+    rotation: BABYLON.Quaternion;
+    antiGravity?: boolean;
+    onDepartedRoad?: boolean;
+    courseAntiGravity?: boolean;
+}
+export interface IKartRescueEvent {
+    reason: EKartRescueReason;
+    kart: StandardKartController;
+}
+export interface IKartRecoverySample {
+    positionY: number;
+    upDotWorldUp: number;
+    grounded: boolean;
+    antiGravity: boolean;
+    excused: boolean;
+    throttleHeld?: boolean;
+    movingSpeed?: number;
+    stallExcused?: boolean;
+}
+export declare const KART_STALLED_SPEED: number;
+export declare const KART_STALLED_SECONDS: number;
+export declare function isKartStalled(sample: IKartRecoverySample): boolean;
+export declare const KART_FLIPPED_UP_DOT: number;
+export declare const KART_FLIPPED_SECONDS: number;
+export declare function shouldFallRescue(positionY: number, floorY: number, airborneSeconds: number, airborneLimitSeconds: number): boolean;
+export declare function isKartFlipped(sample: IKartRecoverySample): boolean;
+export declare function nearestEquivalentAngle(targetDegrees: number, referenceDegrees: number): number;
+export declare function isAtOrPastLoopIndex(index: number, limitIndex: number, count: number): boolean;
+export declare const FINISH_LINE_HOLD_METERS: number;
+export declare function indexBeforeFinishLine(points: BABYLON.Vector3[], startIndex: number, distancePastLine: (point: BABYLON.Vector3) => number | null): number;
+export declare function pointBeforeFinishLine(lastBefore: BABYLON.Vector3, firstAfter: BABYLON.Vector3, distancePastLine: (point: BABYLON.Vector3) => number | null): BABYLON.Vector3 | null;
+export declare const COURSE_MEMORY_CELL_METERS: number;
+export declare const COURSE_MEMORY_STATE_METERS: number;
+export declare const COURSE_MEMORY_PLACEMENT_METERS: number;
+export declare const COURSE_MEMORY_SAME_ROAD_DOT: number;
+export interface IKartCourseSample {
+    position: BABYLON.Vector3;
+    up: BABYLON.Vector3;
+    antiGravity: boolean;
+    statesByKart: Map<number, boolean>;
+}
+export declare class KartCourseMemory {
+    private static readonly memories;
+    private readonly cells;
+    static forScene(scene: BABYLON.Scene | null): KartCourseMemory;
+    record(position: BABYLON.Vector3, up: BABYLON.Vector3, antiGravity: boolean, kartKey?: number): void;
+    nearestSample(position: BABYLON.Vector3, up: BABYLON.Vector3 | null, maxDistance: number): IKartCourseSample | null;
+    stateAt(position: BABYLON.Vector3, up: BABYLON.Vector3): boolean | null;
+    clear(): void;
+    private forEachSampleNear;
+    private static cellKey;
+}
+export declare const ANTIGRAVITY_END_RESCUE_METERS: number;
+export declare function rescueAntiGravityState(placementOnWall: boolean, knownState: boolean | null, leftRoadInAntiGravity: boolean, onDepartedRoad: boolean, nearOwnAntiGravityEnd?: boolean): boolean;
+export declare const ANTIGRAVITY_ROAD_NORMAL_Y: number;
+export declare const ANTIGRAVITY_BANKED_ROAD_NORMAL_Y: number;
+export declare const ANTIGRAVITY_BANKED_ARM_SECONDS: number;
+export declare const ANTIGRAVITY_FLAT_ROAD_END_SECONDS: number;
+export declare const ANTIGRAVITY_UPRIGHT_NORMAL_Y: number;
+export declare const ANTIGRAVITY_ROAD_END_SECONDS: number;
+export declare const ANTIGRAVITY_REENTRY_GUARD_SECONDS: number;
+export declare const ANTIGRAVITY_BANK_MIN_ALIGN_DOT: number;
+export declare const ANTIGRAVITY_BANK_MIN_TURN_DOT: number;
+export interface IKartBankLatchSample {
+    latched: boolean;
+    enabled: boolean;
+    wasGrounded: boolean;
+    sameBody: boolean;
+    hitNormal: BABYLON.Vector3;
+    lastGroundNormal: BABYLON.Vector3;
+    kartUp: BABYLON.Vector3;
+}
+export declare function isSmoothBankOntoAntiGravityRoad(sample: IKartBankLatchSample): boolean;
+export interface IKartAntiGravityRoadSample {
+    latched: boolean;
+    insideEntryVolume: boolean;
+    grounded: boolean;
+    groundNormalY: number;
+}
+export declare class KartAntiGravityRoadWatch {
+    private armed;
+    private uprightSeconds;
+    private flatSeconds;
+    private bankedSeconds;
+    tick(sample: IKartAntiGravityRoadSample, deltaSeconds: number): boolean;
+    reset(): void;
+    isArmed(): boolean;
+}
+export declare const ANTI_GRAVITY_INVERTED_MAX_UP_Y: number;
+export declare const ANTI_GRAVITY_INVERTED_MAX_GROUND_NORMAL_Y: number;
+export declare const ANTI_GRAVITY_INVERTED_MAX_ALIGN_DOT: number;
+export declare const ANTI_GRAVITY_INVERTED_RECOVER_SECONDS: number;
+export interface IKartInvertedSample {
+    latched: boolean;
+    grounded: boolean;
+    upY: number;
+    groundNormalY: number;
+    upDotGroundNormal: number;
+}
+export declare function isTurnedOverOntoWall(sample: IKartInvertedSample): boolean;
+export declare class KartAntiGravityInvertedWatch {
+    private invertedSeconds;
+    tick(sample: IKartInvertedSample, deltaSeconds: number): boolean;
+    reset(): void;
+}
+export declare class KartRecoveryWatch {
+    airborneLimitSeconds: number;
+    floorY: number;
+    flippedLimitSeconds: number;
+    stalledLimitSeconds: number;
+    private airborneSeconds;
+    private flippedSeconds;
+    private stalledSeconds;
+    tick(sample: IKartRecoverySample, deltaSeconds: number): EKartRescueReason | null;
+    reset(): void;
+    getStalledSeconds(): number;
+    getAirborneSeconds(): number;
+    getFlippedSeconds(): number;
+}
+export declare class KartRescuePlacer {
+    static readonly SEARCH_RADIUS: number;
+    static readonly SURFACE_LIFT: number;
+    static readonly DRIVABLE_TAGS: string[];
+    static readonly WALKABLE_NORMAL_Y: number;
+    static readonly KART_CLEARANCE: number;
+    private static readonly CLEARANCE_RAY_OFFSET;
+    private static readonly SEARCH_DIRECTIONS;
+    static readonly SAME_ROAD_DOT: number;
+    static placeNear(point: BABYLON.Vector3, facingTarget: BABYLON.Vector3, preferredUp?: BABYLON.Vector3 | null): IKartRescuePlacement | null;
+    static surfaceRotation(surfaceUp: BABYLON.Vector3, heading: BABYLON.Vector3): BABYLON.Quaternion;
+    private static hasKartClearance;
+    private static tagOf;
+    private static buildSearchDirections;
+}
+export declare class KartRigLookup {
+    static findNode(root: BABYLON.TransformNode, name: string): BABYLON.TransformNode | null;
+    static findAnimator(root: BABYLON.TransformNode, nodeName: string): Animator | null;
+    static setTrigger(animators: Animator[], parameterName: string): number;
+    static hasBool(animator: Animator, parameterName: string): boolean;
+    static setBool(animators: Animator[], parameterName: string, value: boolean): number;
+}
+export declare const TIRE_GLOW_LINE_PROPERTY: string;
+export declare const KART_BODY_GLOW_PROPERTY: string;
+export declare const TIRE_GLOW_RIM_PROPERTY: string;
+export declare const TIRE_GLOW_CENTER_PROPERTY: string;
+export declare const TIRE_GLOW_LINE_INTENSITY: number;
+export declare const TIRE_GLOW_BLEND_RATE: number;
+export declare const TIRE_GLOW_FLASH_FADE_RATE: number;
+export declare const TIRE_GLOW_FLASH_SECONDS: number;
+export declare const TIRE_GLOW_WRITE_EPSILON: number;
+export declare const TIRE_GLOW_DEFAULT_TINT: string;
+export interface IKartGlowMaterial {
+    getGraphInfo(): {
+        properties?: {
+            [unityName: string]: string;
+        };
+    } | null;
+    setVector(unityName: string, value: BABYLON.Vector4): void;
+    setColor(unityName: string, value: BABYLON.Color4): void;
+}
+export type KartGlowMaterial = BABYLON.Material & IKartGlowMaterial;
+export declare function isKartGlowMaterial(material: BABYLON.Material | null): material is KartGlowMaterial;
+export declare class KartTireGlow {
+    private readonly slots;
+    private lineBlend;
+    private flashLevel;
+    private flashSeconds;
+    private wasAntiGravity;
+    private writtenLine;
+    private writtenFlash;
+    private readonly flashTint;
+    private readonly scratchVector;
+    private readonly scratchColor;
+    constructor(flashTintHex: string);
+    attach(kartRoot: BABYLON.TransformNode): number;
+    tick(antiGravity: boolean, allowFlash: boolean, deltaSeconds: number): void;
+    getLineBlend(): number;
+    getFlashLevel(): number;
+    getMaterialCount(): number;
+    dispose(): void;
+    private findOrCreateSlot;
+    private advanceLineBlend;
+    private advanceFlash;
+    private writeLine;
+    private writeFlash;
+}
+export declare class KartTrackInfo extends ScriptComponent {
+    displayName: string;
+    defaultLaps: number;
+    cupId: string;
+    cupOrder: number;
+    musicSourcePath: string;
+    finalLapMusicSourcePath: string;
+    Is_Dirt_Track: boolean;
+    isRainbowRoad: boolean;
+    minimapImageUrl: string;
+    playerMaxSpeed: number;
+    playerBoostSpeed: number;
+    aiBoostSpeed: number;
+    aiTurnSpeedDivider: number;
+    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+    protected awake(): void;
+    private readProperties;
+}
+declare abstract class KartVolume extends ScriptComponent {
+    protected readProperties(names: string[]): void;
+}
+export declare class KartAntiGravityVolume extends KartVolume {
+    rotateCam: boolean;
+    rotAmountX: number;
+    rotAmountZ: number;
+    canUseBullet: boolean;
+    protected awake(): void;
+}
+export declare class KartAntiGravityExitVolume extends KartVolume {
+    rotateX: boolean;
+    rotateY: boolean;
+    rotateZ: boolean;
+    newRotation: BABYLON.Vector3;
+    protected awake(): void;
+}
+export declare class KartGliderVolume extends KartVolume {
+    glideAngle: number;
+    glideAngleX: number;
+    angleOnly: boolean;
+    protected awake(): void;
+}
+export declare class KartGliderPanel extends KartVolume {
+}
+export declare class KartJumpPanel extends KartVolume {
+    upforce: number;
+    downforce: number;
+    protected awake(): void;
+}
+export declare class KartJumpPanelRotate extends KartVolume {
+    rotateY: number;
+    rotateZ: number;
+    protected awake(): void;
+}
+export declare class KartTrickVolume extends KartVolume {
+}
+export declare class KartAirForceVolume extends KartVolume {
+    force: number;
+    relativeForce: boolean;
+    isForAir: boolean;
+    isForRaceEnd: boolean;
+    isONLYforRaceEnd: boolean;
+    protected awake(): void;
+}
+export declare class KartBoostPad extends KartVolume {
+    duration: number;
+    protected awake(): void;
+}
+export declare class KartCancelDownForce extends KartVolume {
+}
+export declare class KartDirtSurface extends KartVolume {
+    maxSpeed: number;
+    protected awake(): void;
+}
+export declare class KartWaypointDriver extends ScriptComponent {
+    static readonly DRIFT_LEFT_TAG: string;
+    static readonly DRIFT_RIGHT_TAG: string;
+    static readonly START_BOOST_HOLD_SECONDS: number;
+    static readonly RESCUE_GATES_BACK: number;
+    static readonly STUCK_RESPAWN_LIFT: number;
+    static readonly STUCK_PROGRESS_METERS: number;
+    static readonly DRIFT_ENTRY_STEERING_MARGIN: number;
+    static readonly MIN_AIM_DISTANCE_METERS: number;
+    turnSpeedDivider: number;
+    normalMaxSpeed: number;
+    rubberBandMaxSpeed: number;
+    rubberBandCheckpointLead: number;
+    driftMinForwardSpeed: number;
+    startBoostChance: number;
+    autopilot: boolean;
+    autopilotSpeed: number;
+    rubberBandReference: (() => number | null) | null;
+    stuckRecoverySeconds: number;
+    lineLookAheadMeters: number;
+    randomSource: () => number;
+    private kart;
+    private lapCounter;
+    private paths;
+    private currentPathIndex;
+    private currentNodeIndex;
+    private smoothedError;
+    private wasDriftRequested;
+    private goesForStartBoost;
+    private stuckSeconds;
+    private closestGateDistance;
+    private watchedGate;
+    private lastPassedGate;
+    private lastRecoveryTarget;
+    private wedgeAnchor;
+    private wedgeSkipsObstacle;
+    private wasAutoDriving;
+    private readonly steeringTarget;
+    private triggerObserver;
+    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+    protected awake(): void;
+    protected start(): void;
+    protected update(): void;
+    protected destroy(): void;
+    setPaths(paths: BABYLON.TransformNode[][], startPathIndex: number): void;
+    resumeAt(pathIndex: number, nodeIndex: number): void;
+    onLapCompleted(): void;
+    getCurrentNode(): BABYLON.TransformNode | null;
+    getCurrentNodeIndex(): number;
+    getCurrentPathIndex(): number;
+    setLapCounter(lapCounter: KartLapCounter): void;
+    driveFrame(deltaSeconds: number): void;
+    private onGateEntered;
+    private tickStuckRecovery;
+    private respawnOnPath;
+    private placementForRescue;
+    private placementAtNextCheckpoint;
+    private placementBeforeFinishLine;
+    private static nearestGateIndex;
+    private followAutoDrive;
+    private isKartAutoDriving;
+    private resumeAheadOfKart;
+    private skipToNextGate;
+    private resetStuckWatch;
+    private getCurrentPath;
+    private updateSpeedCap;
+    private computeSteering;
+    private aimPoint;
+    private canDrift;
+    private driftEntrySteering;
+    private driftSideOf;
+    private computeThrottle;
+    private getRace;
+}
+export type KartAudioGroup = "engine" | "drift" | "boost" | "hop" | "trick" | "glider" | "impact" | "start" | "item" | "race" | "hover" | "results";
+export interface IKartVoiceSlot {
+    id: string;
+    unity: string;
+    group: KartAudioGroup;
+    sourceName: string;
+    volume: number;
+    looping: boolean;
+    waveform: string;
+    frequency: number;
+    gain: number;
+    attack: number;
+    release: number;
+}
+export declare const KART_VOICE_SLOTS: IKartVoiceSlot[];
+export interface IKartVoiceRota {
+    prefix: string;
+    count: number;
+    unity: string;
+    group: KartAudioGroup;
+    sourceName: string;
+    volume: number;
+    waveform: string;
+    frequency: number;
+    spread: number;
+    gain: number;
+    attack: number;
+    release: number;
+}
+export declare const KART_VOICE_ROTAS: IKartVoiceRota[];
+export declare function buildKartVoiceSlots(counts?: any): IKartVoiceSlot[];
+export type KartVoiceSet = "player" | "opponent";
+export interface IKartClipValues {
+    volume?: number;
+    loop?: boolean;
+    pitch?: number;
+    spatialblend?: number;
+    rolloffmode?: string;
+    mindistance?: number;
+    maxdistance?: number;
+}
+export interface IKartClipDescriptor extends IKartClipValues {
+    filename: string;
+    name?: string;
+    length?: number;
+    type?: string;
+}
+export interface IKartAudioVoice {
+    play(): void;
+    playDelayed(delaySeconds: number): void;
+    stop(): void;
+    isPlaying(): boolean;
+    setPitch(value: number): void;
+    setVolume(value: number): void;
+    advance(dt: number): void;
+    dispose(): void;
+    getPlayCount(): number;
+    getLastDelay(): number;
+}
+export declare class KartSynthVoice implements IKartAudioVoice {
+    private static SharedContext;
+    private static ContextUnavailable;
+    private remaining;
+    private readonly waveform;
+    private readonly frequency;
+    private readonly baseGain;
+    private readonly looping;
+    private readonly attack;
+    private readonly release;
+    private oscillator;
+    private gainNode;
+    private playing;
+    private pitch;
+    private volume;
+    private playCount;
+    private lastDelay;
+    constructor(waveform: string, frequency: number, gain: number, looping: boolean, attack?: number, release?: number);
+    private static GetContext;
+    static ResetContext(): void;
+    play(): void;
+    playDelayed(delaySeconds: number): void;
+    stop(): void;
+    isPlaying(): boolean;
+    advance(dt: number): void;
+    setPitch(value: number): void;
+    setVolume(value: number): void;
+    dispose(): void;
+    getPlayCount(): number;
+    getLastDelay(): number;
+    private startNodes;
+    private stopNodes;
+}
+export declare class KartClipVoice implements IKartAudioVoice {
+    private readonly source;
+    private readonly duration;
+    private remaining;
+    private playing;
+    private playCount;
+    private lastDelay;
+    private stopCount;
+    private started;
+    private seekCount;
+    private clipLoopPoints;
+    private clipLoopRequested;
+    private levelScale;
+    private readonly clipUrl;
+    constructor(source: any, duration?: number, clipUrl?: string);
+    play(): void;
+    playDelayed(delaySeconds: number): void;
+    stop(): void;
+    isStarted(): boolean;
+    useClipLoopPoints(): void;
+    getClipLoop(): number[];
+    seek(offsetSeconds: number, crossfadeSeconds: number): boolean;
+    getSeekCount(): number;
+    isPlaying(): boolean;
+    advance(dt: number): void;
+    setPitch(value: number): void;
+    setVolume(value: number): void;
+    setLevelScale(scale: number): void;
+    getLevelScale(): number;
+    dispose(): void;
+    getPlayCount(): number;
+    getLastDelay(): number;
+    getSource(): any;
+    private watchStart;
+    private stopSource;
+    private getStaticSound;
+    private soundingSeconds;
+    private applyClipLoopPoints;
+    private getClipUrl;
+    private getClipDuration;
+    private static RampInstance;
+}
+export declare class KartClipLoopPoints {
+    private static readonly cache;
+    static Load(url: string): Promise<number[]>;
+    static Parse(bytes: ArrayBuffer): number[];
+    private static ChunkId;
+}
+export declare class KartEnginePlayhead {
+    private unityTime;
+    private voiceTime;
+    private advancing;
+    restart(): void;
+    step(deltaSeconds: number, pitch: number, band: number, rate: number, loop: number[], voiceRunning: boolean): boolean;
+    markSeeked(): void;
+    getTime(): number;
+    getVoiceTime(): number;
+    static Wrap(time: number, loop: number[]): number;
+}
+export declare class KartManagedVoice implements IKartAudioVoice {
+    private readonly soundName;
+    private readonly duration;
+    private playing;
+    private remaining;
+    private playCount;
+    private lastDelay;
+    constructor(soundName: string, duration?: number);
+    play(): void;
+    playDelayed(delaySeconds: number): void;
+    stop(): void;
+    isPlaying(): boolean;
+    setPitch(_value: number): void;
+    setVolume(_value: number): void;
+    advance(dt: number): void;
+    dispose(): void;
+    getPlayCount(): number;
+    getLastDelay(): number;
+    getSoundName(): string;
+}
+export declare class KartMutedVoice implements IKartAudioVoice {
+    play(): void;
+    playDelayed(_delaySeconds: number): void;
+    stop(): void;
+    isPlaying(): boolean;
+    setPitch(_value: number): void;
+    setVolume(_value: number): void;
+    advance(_dt: number): void;
+    dispose(): void;
+    getPlayCount(): number;
+    getLastDelay(): number;
+}
+export interface IKartAudioTarget {
+    transform?: BABYLON.TransformNode;
+    getDriftState(): number;
+    getDriftHopCount?(): number;
+    getDriftTime(): number;
+    getDriftTierTimes?(): number[];
+    getDriftDirection(): number;
+    getCurrentSpeed(): number;
+    isBoosting(): boolean;
+    getBoostTime(): number;
+    getBoostGrantCount?(): number;
+    getLastBoostSource?(): number;
+    isGliding(): boolean;
+    isJumpPanelling?(): boolean;
+    isTricking?(): boolean;
+    isTrickPending?(): boolean;
+    isGrounded?(): boolean;
+    getGlidingTime?(): number;
+    isGliderTrick?(): boolean;
+    getLaunchCharge?(): number;
+    isRevvingOnGrid?(): boolean;
+    isRaceCompleted?(): boolean;
+    isRaceStarted?(): boolean;
+    isRainbowRoad?: boolean;
+    isReverseSkidding?(): boolean;
+    hasStar?(): boolean;
+    isAutoDriving?(): boolean;
+    onKartHitObservable?: BABYLON.Observable<IKartHitEvent>;
+    onKartBumpObservable?: BABYLON.Observable<IKartBumpEvent>;
+}
+export declare class StandardKartAudio extends ScriptComponent {
+    kart: IKartAudioTarget;
+    audioEnabled: boolean;
+    playKartSounds: boolean;
+    voiceSet: KartVoiceSet;
+    driftAudioEnabled: boolean;
+    engineAudioEnabled: boolean;
+    boostAudioEnabled: boolean;
+    hopAudioEnabled: boolean;
+    trickAudioEnabled: boolean;
+    gliderAudioEnabled: boolean;
+    impactAudioEnabled: boolean;
+    startAudioEnabled: boolean;
+    masterVolume: number;
+    boostVoiceCount: number;
+    tierTonePitchStep: boolean;
+    trickVoiceCount: number;
+    driftSteerSourceName: string;
+    driftChargeSourceName: string;
+    engineSourceName: string;
+    idleSourceName: string;
+    boostSourceNamePrefix: string;
+    hopSourceName: string;
+    landSkidSourceName: string;
+    chassisSourceName: string;
+    jumpPanelSourceName: string;
+    gliderStartSourceName: string;
+    gliderFlutterSourceName: string;
+    gliderCloseSourceName: string;
+    startRevSourceName: string;
+    startDashSourceName: string;
+    gliderVoiceSourceName: string;
+    trickVoiceNamePrefix: string;
+    protected driftSteerVoice: IKartAudioVoice;
+    protected driftChargeVoice: IKartAudioVoice;
+    protected engineVoice: IKartAudioVoice;
+    protected idleVoice: IKartAudioVoice;
+    protected boostVoices: IKartAudioVoice[];
+    protected hopVoice: IKartAudioVoice;
+    protected landSkidVoice: IKartAudioVoice;
+    protected chassisVoice: IKartAudioVoice;
+    protected jumpPanelVoice: IKartAudioVoice;
+    protected gliderStartVoice: IKartAudioVoice;
+    protected gliderFlutterVoice: IKartAudioVoice;
+    protected gliderCloseVoice: IKartAudioVoice;
+    protected startRevVoice: IKartAudioVoice;
+    protected startDashVoice: IKartAudioVoice;
+    protected gliderTrickVoice: IKartAudioVoice;
+    protected trickVoices: IKartAudioVoice[];
+    protected voices: Map<string, IKartAudioVoice>;
+    protected slots: Map<string, IKartVoiceSlot>;
+    protected mutedVoices: Set<string>;
+    protected mutedGroups: Set<string>;
+    voiceSourceNames: any;
+    voiceClips: Record<string, IKartClipDescriptor>;
+    preferVoiceClips: string[];
+    voiceSlotsMuted: string[];
+    voiceSoundNames: any;
+    voiceTunings: any;
+    voiceVolumes: any;
+    protected rotaCursors: any;
+    protected soundCount: number;
+    protected lastBoostTime: number;
+    protected lastBoostGrantCount: number;
+    protected lastChargeTier: number;
+    protected engineTime: number;
+    protected enginePlayhead: KartEnginePlayhead;
+    protected enginePitch: number;
+    protected idleLevel: number;
+    protected sceneEntryFinished: boolean;
+    protected chargeRetriggerCount: number;
+    protected lastDriftState: number;
+    protected lastDriftHopCount: number;
+    protected lastJumpPanel: boolean;
+    protected lastTricking: boolean;
+    protected lastGrounded: boolean;
+    protected lastGliding: boolean;
+    protected lastGliderTrick: boolean;
+    protected trickAnimCounter: number;
+    protected hopCount: number;
+    protected trickVoiceCountFired: number;
+    protected landCount: number;
+    protected lastStar: boolean;
+    protected lastAutoDriving: boolean;
+    protected kartHitObserver: BABYLON.Observer<IKartHitEvent>;
+    protected kartBumpObserver: BABYLON.Observer<IKartBumpEvent>;
+    protected sceneRevealed: boolean;
+    protected awake(): void;
+    protected start(): void;
+    protected update(): void;
+    protected reveal(): void;
+    protected destroy(): void;
+    protected awakeAudioState(): void;
+    protected initAudioState(): void;
+    protected seedEdgeLedger(): void;
+    protected destroyAudioState(): void;
+    static SlotDuration(slot: IKartVoiceSlot): number;
+    protected tuneSlot(slot: IKartVoiceSlot): IKartVoiceSlot;
+    protected resolveSlot(slot: IKartVoiceSlot): IKartAudioVoice;
+    protected resolveClipTier(slot: IKartVoiceSlot): IKartAudioVoice;
+    static ReadSlotList(value: unknown): string[];
+    static ClipDurationSeconds(slot: IKartVoiceSlot, clip: IKartClipDescriptor, looping: boolean): number;
+    static ClipLooping(slot: IKartVoiceSlot, clip: IKartClipDescriptor): boolean;
+    static AwakeNow(component: ScriptComponent): void;
+    protected buildClipSource(slot: IKartVoiceSlot, clip: IKartClipDescriptor): IKartAudioVoice;
+    protected loadClipSource(source: any, filename: string): void;
+    protected bindVoiceAliases(): void;
+    protected collectRota(prefix: string): IKartAudioVoice[];
+    protected findChildNode(name: string): BABYLON.TransformNode;
+    protected resolveKartRoot(): BABYLON.TransformNode;
+    protected forEachVoice(callback: (voice: IKartAudioVoice) => void): void;
+    protected updateAudioState(): void;
+    protected subscribeKartEvents(): void;
+    protected unsubscribeKartEvents(): void;
+    protected tickReverseSkidAudio(): void;
+    protected tickStarAudio(): void;
+    protected tickBulletAudio(): void;
+    protected tickHopAudio(): void;
+    protected tickJumpPanelAudio(): void;
+    protected tickTrickAudio(): void;
+    static VoiceForCounter(counter: number, length: number): number;
+    protected tickImpactAudio(): void;
+    protected tickGliderAudio(): void;
+    protected tickStartAudio(): void;
+    protected isStartRevHeld(): boolean;
+    protected tickDriftAudio(): void;
+    protected tickBoostAudio(): void;
+    protected playRocketStartVoice(): void;
+    static SourceSpeaks(source: number): boolean;
+    protected checkIfPlaying(): boolean;
+    protected tickEngineAudio(dt: number): void;
+    protected applyEngineBand(deltaSeconds: number, band: number, rate: number): void;
+    protected useClipLoopPoints(): void;
+    static EngineBand(voiceSet: KartVoiceSet, speed: number): number;
+    protected tickIdleLevel(dt: number): void;
+    protected hasSceneEntryFinished(): boolean;
+    static EnginePitchTarget(boosting: boolean, gliding: boolean): number;
+    static SynthEnginePitch(enginePitch: number, engineTime: number): number;
+    static EngineBandTime(speed: number, current: number): number;
+    static OpponentEngineBandTime(speed: number, current: number): number;
+    static NormalizeVoiceSet(value: any): KartVoiceSet;
+    protected engineVolume(gliding: boolean): number;
+    protected applyVoiceSetSpatial(): void;
+    protected applyPlayerPerceivedLevels(): void;
+    protected applyPlayerSlotLevel(slotId: string, voice: IKartAudioVoice): void;
+    protected muteSynthsOnRiggedKart(): void;
+    static RecordedLevelFactor(slotId: string): number;
+    static PerceivedGain(source: any, distance: number): number;
+    static UnityAttenuation(mode: string, distance: number, minimum: number, maximum: number): number;
+    protected slotVolume(slotId: string): number;
+    protected applySpatialRole(voice: IKartAudioVoice, spatialBlend: number): void;
+    getDriftSteerVoice(): IKartAudioVoice;
+    getDriftChargeVoice(): IKartAudioVoice;
+    getEngineVoice(): IKartAudioVoice;
+    getIdleVoice(): IKartAudioVoice;
+    getBoostVoices(): IKartAudioVoice[];
+    getChargeRetriggerCount(): number;
+    getSoundCount(): number;
+    getEngineTime(): number;
+    getEnginePitch(): number;
+    getIdleLevel(): number;
+    setSceneEntryFinished(finished: boolean): void;
+    getHopVoice(): IKartAudioVoice;
+    getLandSkidVoice(): IKartAudioVoice;
+    getChassisVoice(): IKartAudioVoice;
+    getJumpPanelVoice(): IKartAudioVoice;
+    getGliderStartVoice(): IKartAudioVoice;
+    getGliderFlutterVoice(): IKartAudioVoice;
+    getGliderCloseVoice(): IKartAudioVoice;
+    getStartRevVoice(): IKartAudioVoice;
+    getStartDashVoice(): IKartAudioVoice;
+    getGliderTrickVoice(): IKartAudioVoice;
+    getTrickVoices(): IKartAudioVoice[];
+    getTrickAnimCounter(): number;
+    getHopCount(): number;
+    getTrickVoiceFiredCount(): number;
+    getLandCount(): number;
+    getVoiceIds(): string[];
+    getVoice(id: string): IKartAudioVoice;
+    getVoiceSlot(id: string): IKartVoiceSlot;
+    setVoice(id: string, voice: IKartAudioVoice): void;
+    setVoiceSource(id: string, source: any, duration?: number): void;
+    setVoiceEnabled(id: string, enabled: boolean): void;
+    isVoiceEnabled(id: string): boolean;
+    setGroupEnabled(group: KartAudioGroup, enabled: boolean): void;
+    isGroupEnabled(group: KartAudioGroup): boolean;
+    playVoice(id: string, volumeScale?: number): boolean;
+    isVoiceAllowed(id: string): boolean;
+    protected revealAudioState(): void;
+    protected isHeldBehindSplash(): boolean;
+    stopVoice(id: string): void;
+    isVoicePlaying(id: string): boolean;
+    playRota(prefix: string, volumeScale?: number): boolean;
+    playCoin(volumeScale?: number): boolean;
+    playBump(volumeScale?: number): boolean;
+    playItemHit(volumeScale?: number): boolean;
+    playObstacleHit(volumeScale?: number): boolean;
+    playHurt(volumeScale?: number): boolean;
+    playStar(volumeScale?: number): boolean;
+    playBullet(phase: number, volumeScale?: number): boolean;
+    playHoverEnter(volumeScale?: number): boolean;
+    playHoverCharge(volumeScale?: number): boolean;
+    playHoverFinish(volumeScale?: number): boolean;
+    playFinish(volumeScale?: number): boolean;
+    playResults(position: number): void;
+    setSurfaceDrift(active: boolean): void;
+}
+export interface IKartCameraTarget {
+    isPlayerBeingMoved(): boolean;
+    isAntiGravity(): boolean;
+    getAntiGravityRotAmountX?(): number;
+    getAntiGravityRotAmountZ?(): number;
+    isAntiGravityCamRotate?(): boolean;
+    isGliding(): boolean;
+    getGlideAngleX?(): number;
+    getGlideAngleZ?(): number;
+    isBoosting(): boolean;
+    isJumpPanelling(): boolean;
+    isTrickPending?(): boolean;
+}
+export declare class StandardKartCamera extends ScriptComponent {
+    player: BABYLON.TransformNode;
+    playerNodeName: string;
+    kart: IKartCameraTarget;
+    camera: any;
+    race: any;
+    raceStarted: boolean;
+    raceCompleted: boolean;
+    raceEndFOV: number;
+    followRate: number;
+    jumpPanelRate: number;
+    glideRate: number;
+    trickLevelRate: number;
+    childRate: number;
+    boostDollyRate: number;
+    raceEndReturnRate: number;
+    heightOffset: number;
+    orig_pos: BABYLON.Vector3;
+    boost_pos: BABYLON.Vector3;
+    cameraLocalPosition: BABYLON.Vector3;
+    cameraLocalRotation: BABYLON.Quaternion;
+    defaultChildPitch: number;
+    antiGravityPosY: number;
+    antiGravityTailSeconds: number;
+    rotAmountX: number;
+    rotAmountZ: number;
+    rotateCamAntiGravity: boolean;
+    glideAngleX: number;
+    glideAngleZ: number;
+    protected child: BABYLON.TransformNode;
+    protected antiGravityTail: number;
+    private readonly targetRotation;
+    private readonly childTarget;
+    private readonly rigPosition;
+    private readonly childPosition;
+    private readonly unitScale;
+    private readonly cameraLocalMatrix;
+    private readonly cameraWorldMatrix;
+    private readonly cameraWorldPosition;
+    private readonly cameraWorldRotation;
+    private readonly cameraWorldScale;
+    protected awake(): void;
+    protected start(): void;
+    protected late(): void;
+    protected destroy(): void;
+    protected awakeCameraState(): void;
+    protected initCameraState(): void;
+    protected lateCameraState(): void;
+    protected applyRaceEndFraming(raceCompleted: boolean): void;
+    protected destroyCameraState(): void;
+    protected updateRigPosition(antiGravity: boolean, gliding: boolean, raceCompleted: boolean): void;
+    protected playerYaw(): number;
+    protected isTrickPending(): boolean;
+    protected updateRigRotation(dt: number, gliding: boolean, jumpPanel: boolean, trickPending: boolean, antiGravity: boolean, raceStarted: boolean): void;
+    protected copyPlayerRotationTo(out: BABYLON.Quaternion): void;
+    protected volumeRotAmountX(): number;
+    protected isRaceStarted(): boolean;
+    protected isRaceCompleted(): boolean;
+    protected volumeRotAmountZ(): number;
+    protected volumeGlideAngleX(): number;
+    protected volumeGlideAngleZ(): number;
+    protected isAntiGravityCamRotate(): boolean;
+    protected updateChildRotation(dt: number, leaning: boolean): void;
+    protected lerpChildTo(target: BABYLON.Vector3, k: number, leaning: boolean): void;
+    protected updateChildPosition(dt: number, boosting: boolean, trickPending: boolean, leaning: boolean, raceCompleted: boolean): void;
+    protected writeCamera(): void;
+    getChild(): BABYLON.TransformNode;
+    getAntiGravityTail(): number;
+    getChildTargetY(boosting: boolean, trickPending?: boolean, dt?: number, raceCompleted?: boolean): number;
+    isLeaning(): boolean;
+    isUsingLocalUp(): boolean;
+    getLeanAngle(): number;
+    getHorizonTilt(): number;
+}
+export declare const UNITY_FIXED_STEP: number;
+export declare function approachRate(current: number, target: number, ratePerSecond: number, dt: number): number;
+export declare function approachPerStep(current: number, target: number, fractionPerStep: number, dt: number): number;
+export declare function dampPerStep(value: number, factorPerStep: number, dt: number): number;
+export declare const DRIFT_LATERAL_SLIP: number;
+export declare const DRIFT_MIN_SPEED: number;
+export declare const JUMP_PANEL_DECAY_RATE: number;
+export declare const JUMP_PANEL_THRUST: number;
+export declare const COMPUTER_JUMP_PANEL_THRUST: number;
+export declare const COMPUTER_DRIFT_SPEED_LOSS: number;
+export declare const JUMP_PANEL_ROTATE_SECONDS: number;
+export declare const JUMP_PANEL_ROTATE_RATE: number;
+export declare const TRICK_MIN_SPEED: number;
+export declare const TRICK_SECONDS: number;
+export declare const TRICK_FORCE_START: number;
+export declare const TRICK_FORCE_DECAY: number;
+export declare const TRICK_DECAY_STEP: number;
+export declare const TRICK_FORCE_FLOOR: number;
+export declare const TRICK_LANDING_BOOST: number;
+export declare const GLIDER_TRICK_SPEED: number;
+export declare const GLIDER_TRICK_OPEN_DELAY: number;
+export declare const FALL_RESCUE_MIN_SINK_SPEED: number;
+export declare const ANTI_GRAVITY_LOST_SECONDS: number;
+export declare const ANTI_GRAVITY_SEEK_DISTANCE: number;
+export declare const ANTI_GRAVITY_SEEK_SPEED: number;
+export declare const GROUND_MIN_NORMAL_Y: number;
+export declare const ANTI_GRAVITY_SURFACE_MIN_UP_DOT: number;
+export declare const ANTI_GRAVITY_SIDE_WALL_MAX_RIGHT_DOT: number;
+export declare const ANTI_GRAVITY_FOLD_MIN_UP_DOT: number;
+export declare const ANTI_GRAVITY_FOLD_MIN_TRAVEL_DOT: number;
+export declare const GLIDER_DEPLOY_MIN_UP: number;
+export declare const GLIDER_DEPLOY_MIN_ROAD_UP: number;
+export declare const GLIDER_TRICK_PAYOUT_DELAY: number;
+export declare const GLIDER_TRICK_BOOST: number;
+export declare const GLIDER_ROTATE_STRENGTH: number;
+export declare const COAST_MODEL_SETTLE_RATE: number;
+export declare const UNITY_ACCEL_RATE: number;
+export declare const BRAKE_FRACTION_PER_STEP: number;
+export declare const BRAKE_REVERSE_SPEED_DIVISOR: number;
+export declare const BRAKE_REVERSE_ROTATE_STRENGTH: number;
+export declare const KART_DRIFT_BRAKE_FLOOR_FRACTION: number;
+export declare const KART_DRIFT_BRAKE_RATE: number;
+export declare function driftBrakeSpeed(currentSpeed: number, maxSpeed: number, floorFraction: number, ratePerSecond: number, dt: number): number;
+export declare const KART_BOOST_ACCEL_RATE: number;
+export declare const KART_DRIFT_TIERS_UNITY: number[];
+export declare const KART_DRIFT_TIERS_TUNED: number[];
+export declare const KART_DRIFT_TIER_BOOST_SECONDS_UNITY: number[];
+export declare const GLIDER_PITCH_RANGE: number;
+export declare const GLIDER_PITCH_CLAMP: number;
+export declare const GLIDER_PITCH_RATE: number;
+export declare const GLIDER_DIVE_FORCE: number;
+export declare const GLIDER_LIFT_FORCE: number;
+export declare const GLIDER_LIFT_SECONDS: number;
+export declare const GLIDER_ROLL_RANGE: number;
+export declare const GLIDER_ROLL_RATE: number;
+export declare const GLIDER_ROLL_SMOOTH_RATE: number;
+export declare const GLIDER_CLOSE_CONFIRM: number;
+export declare const GLIDER_TRICK_FACE_SECONDS: number;
+export declare const GLIDER_TRICK_CLOSE_CONFIRM: number;
+export declare const GLIDER_LANDING_SECONDS: number;
+export declare const GLIDER_PANEL_BOOST: number;
+export declare const GLIDER_IMPULSE_SECONDS: number;
+export declare const GLIDER_IMPULSE_START: number;
+export declare const GLIDER_IMPULSE_END: number;
+export declare const GLIDER_ARCADE_SLOPE_MIN: number;
+export declare const GLIDER_ARCADE_SLOPE_FLOOR: number;
+export declare const GLIDER_ARCADE_SLOPE_SCALE: number;
+export declare const GLIDER_ARCADE_SINK_RATE: number;
+export declare const WHEEL_STEER_ANGLE: number;
+export declare const WHEEL_STEER_RATE: number;
+export declare const ANTIGRAVITY_SURFACE_TAIL: number;
+export declare const WHEEL_STEER_FREEZE_RATE: number;
+export declare const WHEEL_SPIN_SPEED_SWITCH: number;
+export declare const WHEEL_SPIN_SLOW_FACTOR: number;
+export declare const WHEEL_ACCELERATE_BACKWARDS_PASSES: number;
+export declare const WHEEL_ACCELERATE_BACKWARDS_FRONT_FACTOR: number;
+export declare const WHEEL_ACCELERATE_BACKWARDS_REAR_SOURCE: number;
+export declare const WHEEL_SPIN_RADIANS_PER_UNIT: number;
+export declare const WHEEL_ANTIGRAVITY_RATE: number;
+export declare const WHEEL_ANTIGRAVITY_ANGLE: number;
+export declare const WHEEL_ANTIGRAVITY_SPREAD: number;
+export declare const WHEEL_POSE_SIGN: number[];
+export declare const WHEEL_SPIN_AXIS: BABYLON.Vector3;
+export declare const WHEEL_STEER_AXIS: BABYLON.Vector3;
+export declare const WHEEL_POSE_AXIS: BABYLON.Vector3;
+export declare const ARM_ANTIGRAVITY_SCALE: number[];
+export declare const WHEEL_ANIMATOR_TRIGGER: string;
+export declare const DEG_TO_RAD: number;
+export declare const EXIT_ROTATE_EPSILON: number;
+export declare function wrapAngle(radians: number): number;
+export declare function approachAngle(current: number, target: number, fraction: number): number;
+export interface IKartKeyframe {
+    time: number;
+    value: number;
+}
+export declare function sampleTrack(track: IKartKeyframe[], time: number): number;
+export declare const KART_HOP_TRACK: IKartKeyframe[];
+export declare const KART_SHAKE_TRACK: IKartKeyframe[];
+export declare const KART_ANTIGRAVITY_TRACK: IKartKeyframe[];
+export declare const KART_IDLE_TRACK: IKartKeyframe[];
+export declare const KART_IDLE_LOOP_SECONDS: number;
+export declare const KART_START_TURBO_FRAME_RATE: number;
+export declare const KART_START_TURBO_STATE_SPEED: number;
+export declare const KART_START_TURBO_LIFT: number[];
+export declare const KART_START_TURBO_SWAY: number[];
+export declare const KART_START_TURBO_YAW: number[];
+export interface IKartStartTurboPose {
+    lift: number;
+    sway: number;
+    yaw: number;
+}
+export declare function sampleStartTurboPose(time: number, result: IKartStartTurboPose): IKartStartTurboPose;
+export declare const GRID_REV_WHEEL_SPIN_SOURCE: number;
+export declare const ROCKET_START_SMOOTHING_PASSES: number;
+export declare const ROCKET_START_SMOOTHING_STEP_SECONDS: number;
+export declare function rocketStartLaunchSpeed(currentSpeed: number, boostSpeed: number): number;
+export declare const KART_DRIFT_DUST_SECONDS: number;
+export declare function driftDustWindowSeconds(firstSparkTierSeconds: number): number;
+export declare const KART_UNDERWATER_ROLL_DEGREES: number;
+export declare const KART_UNDERWATER_DRIFT_LEFT_PARAMETER: string;
+export declare const KART_UNDERWATER_DRIFT_RIGHT_PARAMETER: string;
+export declare const KART_UNDERWATER_OFFSET: number;
+export declare const KART_UNDERWATER_LIFT: number;
+export declare const KART_UNDERWATER_BLEND: number;
+export declare const KART_DEPTH_WATER_NODE_NAME: string;
+export declare const KART_WATER_VERTICAL_DAMPING: number;
+export declare const KART_PROPELLER_NODE_NAME: string;
+export declare const KART_PROPELLER_SPIN_OFFSET: number;
+export declare const KART_PROPELLER_RACE_MIN_DEGREES: number;
+export declare const KART_PROPELLER_RACE_MAX_DEGREES: number;
+export declare const KART_PROPELLER_FINISH_MIN_DEGREES: number;
+export declare const KART_PROPELLER_FINISH_MAX_DEGREES: number;
+export declare function propellerStepDegrees(realCurrentSpeed: number, currentSpeed: number, raceCompleted: boolean): number;
+export declare const KART_ANIMATOR_TRIGGERS: string[];
+export interface IKartSpeedCapState {
+    grounded: boolean;
+    boost: boolean;
+    star: boolean;
+    desiredMaxSpeed: number;
+    boostSpeed: number;
+}
+export declare function selectMaxSpeed(state: IKartSpeedCapState): number;
+export declare function clampAssignedVerticalVelocity(noseY: number, bodyY: number, antiGravity: boolean, jumpPanel?: boolean): number;
+export interface IKartSteerState {
+    realCurrentSpeed: number;
+    drifting: boolean;
+    throttleHeld: boolean;
+}
+export declare function selectSpeedRotateRate(state: IKartSteerState): number;
+export declare function computeYawRate(rotateStrength: number, direction: number, speedRotateRate: number): number;
+export declare enum EKartBoostSource {
+    None = 0,
+    RocketStart = 1,
+    BoostPad = 2,
+    TrickLanding = 3,
+    JumpPanel = 4,
+    GliderExit = 5,
+    GliderTrick = 6,
+    DriftPayout = 7,
+    Item = 8
+}
+export interface IKartAutoDriveOptions {
+    speed: number;
+    seconds: number;
+    exitSpeed: number;
+    targetProvider: () => BABYLON.Vector3;
+}
+export interface IKartHitEvent {
+    kind: EKartHitKind;
+    kart: StandardKartController;
+}
+export interface IKartBumpPartner {
+    root: BABYLON.TransformNode;
+    kart: StandardKartController | null;
+    remote: KartBumpTarget | null;
+}
+export interface IKartBumpEvent {
+    kart: StandardKartController;
+    other: BABYLON.TransformNode;
+    side: number;
+    otherIsRemote: boolean;
+    starContact: boolean;
+}
+export declare enum EKartDriftState {
+    None = 0,
+    Hop = 1,
+    Drift = 2,
+    Boost = 3
+}
+export interface IKartVehicleProfile {
+    hopEnabled: boolean;
+    gliderEnabled: boolean;
+    antiGravityEnabled: boolean;
+    tricksEnabled: boolean;
+    jumpPanelsEnabled: boolean;
+    handItemsEnabled: boolean;
+    propellerEnabled: boolean;
+    tiltEnabled: boolean;
+    bulletBillEnabled: boolean;
+    useBulletBillModel: boolean;
+    trailingItemsEnabled: boolean;
+}
+export type KartVehicleProfileName = "kart" | "arcadeCar";
+export declare class StandardKartController extends ScriptComponent {
+    static readonly CHASSIS_MEMBERSHIP_MASK: number;
+    protected rayCollideMask: number;
+    desiredMaxSpeed: number;
+    boost_speed: number;
+    boostAccelRate: number;
+    driftBrakeRate: number;
+    driftBrakeFloorFraction: number;
+    driftTierTimes: number[];
+    driftTierBoostSeconds: number[];
+    desired_rotate_strength: number;
+    steeringYawRateOverride: number;
+    computerDriven: boolean;
+    sphereRadius: number;
+    sphereCenter: BABYLON.Vector3;
+    chassisMass: number;
+    chassisFriction: number;
+    modelNodeName: string;
+    wheelNodeNames: string[];
+    wheelSpinNodeNames: string[];
+    wheelSteerNodeNames: string[];
+    steeringWheelNodeName: string;
+    armNodeNames: string[];
+    raycastNodeName: string;
+    kartAnimatorNodeName: string;
+    hitAnimatorNodeName: string;
+    driverAnimatorNodeName: string;
+    chassisAnimatorNodeName: string;
+    gliderNodeName: string;
+    headLookNodeName: string;
+    hasHeldItem: boolean;
+    Is_Dirt_Track: boolean;
+    isRainbowRoad: boolean;
+    raycastOffset: BABYLON.Vector3;
+    groundRayDist: number;
+    groundAlignRate: number;
+    modelYawRate: number;
+    driftYawAngle: number;
+    driftLatchDelay: number;
+    driftLatchThreshold: number;
+    vehicleProfile: KartVehicleProfileName | null;
+    hopEnabled: boolean;
+    gliderEnabled: boolean;
+    arcadeGlider: boolean;
+    gliderSlopeMin: number;
+    gliderSlopeFloor: number;
+    gliderSinkRate: number;
+    antiGravityEnabled: boolean;
+    tricksEnabled: boolean;
+    jumpPanelsEnabled: boolean;
+    handItemsEnabled: boolean;
+    propellerEnabled: boolean;
+    tiltEnabled: boolean;
+    bulletBillEnabled: boolean;
+    useBulletBillModel: boolean;
+    trailingItemsEnabled: boolean;
+    bodyLeanAngle: number;
+    antiGravityExitRateX: number;
+    antiGravityExitRateYZ: number;
+    correctArrowKeyGate: boolean;
+    correctNeutralSteer: boolean;
+    sparkTier1Color: string;
+    sparkTier2Color: string;
+    sparkTier3Color: string;
+    rayIncludeLayers: string[];
+    static readonly UNITY_LAYERS: string[];
+    static readonly KART_PROFILE: Readonly<IKartVehicleProfile>;
+    static readonly ARCADE_CAR_PROFILE: Readonly<IKartVehicleProfile>;
+    static readonly VEHICLE_PROFILES: Readonly<Record<KartVehicleProfileName, Readonly<IKartVehicleProfile>>>;
+    private static readonly PROFILE_GATED_TAGS;
+    protected currentspeed: number;
+    protected REALCURRENTSPEED: number;
+    protected rotate_strength: number;
+    protected Drift_time: number;
+    protected Boost_time: number;
+    protected drift_direction: number;
+    protected drift_right: boolean;
+    protected drift_left: boolean;
+    protected drifting: boolean;
+    protected direction: number;
+    protected driftState: EKartDriftState;
+    protected grounded: boolean;
+    protected antiGravity: boolean;
+    protected antiGravityVolumes: BABYLON.TransformNode[];
+    protected antiGravityRotAmountX: number;
+    protected antiGravityRotAmountZ: number;
+    protected antiGravityRotateCam: boolean;
+    protected exitRotateActive: boolean;
+    protected exitRotateX: boolean;
+    protected exitRotateY: boolean;
+    protected exitRotateZ: boolean;
+    protected exitRotateTarget: BABYLON.Vector3;
+    private exitRotateVolume;
+    private exitEuler;
+    private exitQuaternion;
+    private jumpRotation;
+    private gliderEuler;
+    protected GLIDER_FLY: boolean;
+    protected groundNormal: BABYLON.Vector3;
+    protected yawRate: number;
+    protected slipAngle: number;
+    protected inputThrottle: number;
+    protected inputBraking: boolean;
+    protected inputSteering: number;
+    protected inputDrifting: boolean;
+    protected inputTrick: boolean;
+    protected trickTime: number;
+    protected trickArmed: boolean;
+    protected trickPerformed: boolean;
+    protected trickPressed: boolean;
+    protected verticalAccumulates: boolean;
+    protected inputPitch: number;
+    protected chassisBody: BABYLON.PhysicsBody;
+    protected raycastNode: BABYLON.TransformNode;
+    protected JUMP_PANEL: boolean;
+    protected upForce: number;
+    protected downForce: number;
+    protected jumpPanelRotateTime: number;
+    protected jumpPanelRotateTarget: BABYLON.Quaternion;
+    protected glidingTime: number;
+    protected glideAngleX: number;
+    protected glideAngleZ: number;
+    protected gliderOpenDelay: number;
+    protected gliderTrick: boolean;
+    protected gliderTrickPayout: number;
+    protected gliderPitch: number;
+    protected gliderSlope: number;
+    protected sceneGravityY: number;
+    protected gliderRoll: number;
+    protected gliderRollVelocity: number;
+    protected gliderImpulseTime: number;
+    protected probeGrounded: boolean;
+    protected driftEntryGrounded: boolean;
+    protected groundDistance: number;
+    protected activeGroundRayDist: number;
+    protected gliderLandingTimer: number;
+    protected gliderLanded: boolean;
+    protected max_speed: number;
+    protected Boost: boolean;
+    protected cancelAddforceDown: boolean;
+    protected airForceVolumes: BABYLON.TransformNode[];
+    protected wheelNodes: BABYLON.TransformNode[];
+    protected wheelRestPositions: BABYLON.Vector3[];
+    protected wheelRestRotations: BABYLON.Quaternion[];
+    protected antiGravityTirePositions: BABYLON.Vector3[];
+    protected antiGravityTireTargets: BABYLON.Vector3[];
+    antiGravityTireColor: string;
+    protected steeringWheelRest: BABYLON.Quaternion;
+    protected armNodes: BABYLON.TransformNode[];
+    protected armRestScales: BABYLON.Vector3[];
+    protected steeringWheelNode: BABYLON.TransformNode;
+    protected wheelSteer: number;
+    protected wheelSpin: number;
+    protected wheelSpinNodes: BABYLON.TransformNode[];
+    protected wheelSpinRests: BABYLON.Quaternion[];
+    protected wheelSteerNodes: BABYLON.TransformNode[];
+    protected wheelSteerRests: BABYLON.Quaternion[];
+    protected wheelAntiGravity: number;
+    private wheelSpinRotation;
+    private wheelSteerRotation;
+    private wheelPoseRotation;
+    private wheelCompose;
+    protected onDirt: boolean;
+    protected awake(): void;
+    protected start(): void;
+    protected update(): void;
+    protected late(): void;
+    protected step(): void;
+    protected fixed(): void;
+    protected destroy(): void;
+    protected awakeKartState(): void;
+    protected initKartState(): void;
+    private attachCollisionEvents;
+    protected onVolumeEnter(other: BABYLON.TransformNode): void;
+    protected onVolumeExit(other: BABYLON.TransformNode): void;
+    isVolumeEnabled(tag: string): boolean;
+    applyVehicleProfile(profile: KartVehicleProfileName | Partial<IKartVehicleProfile>): void;
+    getVehicleProfile(): IKartVehicleProfile;
+    getVehicleProfileName(): KartVehicleProfileName | null;
+    private matchesVehicleProfile;
+    protected enterAntiGravityVolume(volume: BABYLON.TransformNode): void;
+    protected exitAntiGravity(volume: BABYLON.TransformNode): void;
+    private leaveAntiGravityExitVolume;
+    protected tickAntiGravity(dt: number): void;
+    protected applyAntiGravityExitRotation(dt: number): void;
+    private readVolumeField;
+    private hasJumpPanelRotatePayload;
+    private readVectorArray;
+    private buildAntiGravityTireTargets;
+    private readUnityColor;
+    private readVolumeNumber;
+    private readVolumeFlag;
+    private readVolumeVector;
+    protected enterJumpPanel(volume: BABYLON.TransformNode): void;
+    protected enterJumpPanelRotate(volume: BABYLON.TransformNode): void;
+    protected tickJumpPanel(dt: number): void;
+    protected addLocalStepVelocity(x: number, y: number, z: number): void;
+    protected addLocalVerticalPush(accel: number, canRunGrounded?: boolean): void;
+    protected tickJumpPanelRotate(dt: number): void;
+    protected endJumpPanel(): void;
+    protected tryTrick(): boolean;
+    protected tickTrick(dt: number): void;
+    protected landTrick(): void;
+    protected enterGliderSection(volume: BABYLON.TransformNode): void;
+    protected canDeployGlider(): boolean;
+    protected deployGlider(): void;
+    protected startGliderFlight(): void;
+    protected openGliderCanopy(): void;
+    protected tickGlider(dt: number): void;
+    protected gliderSinkTarget(): number;
+    protected gliderVerticalFor(bodyY: number, dt: number): number;
+    protected applyGliderAttitude(dt: number): void;
+    protected isGliderOnSurface(): boolean;
+    protected seedGliderAttitude(): void;
+    protected closeGlider(): void;
+    protected closeGliderImmediate(): void;
+    protected exitGliderPanel(): void;
+    protected tickGliderImpulse(dt: number): void;
+    protected onBoostPad(volume: BABYLON.TransformNode): void;
+    protected setCancelDownForce(active: boolean): void;
+    protected applyAirForce(dt: number): void;
+    protected applyAirForceVolume(volume: BABYLON.TransformNode, dt: number): void;
+    protected updateWheels(dt: number): void;
+    private rollingWheelSpinSource;
+    private addRearWheelSpin;
+    protected applyWheelPose(): void;
+    setWheelNodes(wheels: BABYLON.TransformNode[], steeringWheel?: BABYLON.TransformNode): void;
+    setWheelDriveNodes(spinNodes: BABYLON.TransformNode[], steerNodes: BABYLON.TransformNode[]): void;
+    private static CaptureRestRotation;
+    setArmNodes(arms: BABYLON.TransformNode[]): void;
+    protected findRigNode(name: string): BABYLON.TransformNode;
+    protected onSurfaceContact(other: BABYLON.TransformNode): void;
+    private ensureChassisBody;
+    protected updateKartState(): void;
+    private readonly rayResult;
+    private groundBody;
+    protected overAntiGravitySurface: boolean;
+    protected overOrdinarySurface: boolean;
+    surfaceAntiGravity: boolean;
+    endAntiGravityWithRoad: boolean;
+    private readonly antiGravityRoadWatch;
+    private readonly antiGravityInvertedWatch;
+    private antiGravityRoadEndSeconds;
+    private lastAntiGravityEndPosition;
+    protected tickAntiGravityRoadEnd(dt: number): void;
+    private tickAntiGravityInvertedRecovery;
+    protected endAntiGravityAtRoadEnd(): void;
+    private recordAntiGravityEnd;
+    protected isAntiGravityReentryGuarded(): boolean;
+    protected antiGravityFromSurface: boolean;
+    protected antiGravitySurfaceTail: number;
+    private readonly driftRayResult;
+    private readonly rayEnd;
+    private readonly rayDirection;
+    private readonly rayExtent;
+    private readonly alignRotation;
+    private readonly alignTarget;
+    private rayQuery;
+    private readonly pendingAcceleration;
+    private readonly assignedVelocity;
+    private readonly bodyVelocity;
+    private readonly localAccel;
+    private readonly speedCapState;
+    protected addWorldAcceleration(x: number, y: number, z: number): void;
+    protected addLocalAcceleration(x: number, y: number, z: number): void;
+    protected addStepVelocity(x: number, y: number, z: number): void;
+    private move;
+    protected endDriftOnCoast(dt: number): void;
+    private readonly yawAxis;
+    private readonly yawRotation;
+    private readonly steerState;
+    protected steer(dt: number): void;
+    protected applyComputerDrift(dt: number): void;
+    protected applyDriftModelYaw(hand: number, dt: number): void;
+    protected applyDriftLateralForce(hand: number): void;
+    protected applyDriftDownforce(): void;
+    protected releaseDriftModelYaw(dt: number): void;
+    protected raceStopDriftRotTimer: number;
+    raceStopDriftRot(seconds: number): void;
+    isRaceStopDriftRotRunning(): boolean;
+    protected tickRaceStopDriftRot(dt: number): void;
+    protected beforeStartAccelTime: number;
+    protected tickBoost(dt: number): void;
+    protected boostGrantCount: number;
+    protected lastBoostSource: EKartBoostSource;
+    protected recordBoostGrant(source: EKartBoostSource): void;
+    grantBoost(seconds: number, source?: EKartBoostSource): void;
+    floorBoost(seconds: number, source?: EKartBoostSource): void;
+    protected payDriftBoost(tier: number): void;
+    chargeLaunch(dt: number): void;
+    releaseLaunch(): boolean;
+    private playRocketStart;
+    protected rearWheelRevSpin: number;
+    protected wasRevvingOnGrid: boolean;
+    protected startTurboOwnedByAnimator: boolean;
+    protected startTurboTime: number;
+    private readonly startTurboPose;
+    isRevvingOnGrid(): boolean;
+    protected updateGridRev(dt: number): void;
+    protected previousDrifting: boolean;
+    protected driftHopCount: number;
+    protected driftPressLatched: boolean;
+    protected driftLatchTimer: number;
+    protected drift(dt: number): void;
+    protected canHop(): boolean;
+    protected hop(): void;
+    protected canEnterDrift(): boolean;
+    protected canHoldDrift(): boolean;
+    protected mustLoseDrift(): boolean;
+    protected enterDrift(): void;
+    protected stopDrift(payout: boolean): void;
+    protected onDriftEntry(): void;
+    private playHop;
+    protected onDriftExit(): void;
+    protected modelNode: BABYLON.TransformNode;
+    private readonly modelRestPosition;
+    private readonly modelRestRotation;
+    private readonly modelPoseOffset;
+    private modelPoseYaw;
+    private modelPoseRoll;
+    protected animator: Animator;
+    protected hitAnimator: Animator;
+    protected driverAnimator: Animator;
+    protected gliderAnimator: Animator;
+    protected chassisAnimator: Animator;
+    protected setGliderCanopy(open: boolean): void;
+    protected driverAnimation: KartDriverAnimation;
+    setDriverPathError(pathError: number): void;
+    protected showsHeldItem(): boolean;
+    protected driverAnimationFrame(): IDriverAnimationFrame;
+    getRigAnimators(): Animator[];
+    protected animatorOwnsWheels(): boolean;
+    protected driftYaw: number;
+    protected hopTime: number;
+    protected shakeTime: number;
+    protected antiGravityLiftTime: number;
+    protected idleTime: number;
+    protected underwaterBlend: number;
+    protected underwaterHand: number;
+    protected animatorOwnsUnderwaterDrift: boolean;
+    private underwaterDriftAnimators;
+    private underwaterDriftLeftWritten;
+    private underwaterDriftRightWritten;
+    protected wasAntiGravity: boolean;
+    private readonly modelRotation;
+    protected fireTrigger(name: string): boolean;
+    protected bindUnderwaterDriftAnimators(): void;
+    protected isUnderwaterDriftSide(side: number): boolean;
+    protected currentDriftHand(): number;
+    protected updateUnderwaterDriftParameters(): void;
+    protected updateModelMotion(dt: number): void;
+    protected advanceUnderwaterPose(deltaSeconds: number): void;
+    protected composeModelPose(): void;
+    private tickModelTriggers;
+    getDriftYaw(): number;
+    getModelLift(): number;
+    getModelNode(): BABYLON.TransformNode;
+    get modelLocalPosition(): BABYLON.Vector3;
+    get modelLocalRotation(): BABYLON.Quaternion;
+    protected FellInWater: boolean;
+    protected outOfBounds: boolean;
+    PlayerBeingMoved: boolean;
+    protected IN_WATER: boolean;
+    protected depthWaterVolumes: BABYLON.TransformNode[];
+    protected propellerNode: BABYLON.TransformNode;
+    protected propellerResolved: boolean;
+    protected propellerShown: boolean;
+    private readonly waterDampingUp;
+    isInWater(): boolean;
+    hasUnderwaterHandling(): boolean;
+    getPropellerNode(): BABYLON.TransformNode;
+    rescanPropeller(): void;
+    protected enterDepthWater(volume: BABYLON.TransformNode): void;
+    protected exitDepthWater(volume: BABYLON.TransformNode): void;
+    protected resetDepthWater(): void;
+    protected applyWaterDamping(dt: number): void;
+    protected tickPropeller(dt: number): void;
+    private updatePropellerVisibility;
+    private resolvePropeller;
+    private showPropeller;
+    RACE_STARTED: boolean;
+    RACE_COMPLETED: boolean;
+    raceStopDrift(): void;
+    private respawnTimer;
+    private respawnStage;
+    private readonly respawnPosition;
+    private readonly respawnRotation;
+    respawnTo(position: BABYLON.Vector3, rotation: BABYLON.Quaternion, immediate?: boolean): void;
+    isRespawning(): boolean;
+    airborneLevelRate: number;
+    private probeMissSeconds;
+    rescueDelaySeconds: number;
+    rescueLiftSpeed: number;
+    fallRescueSeconds: number;
+    flippedRescueSeconds: number;
+    stalledRescueSeconds: number;
+    private readonly stallLastPosition;
+    private stallPositionKnown;
+    rescuePlacement: ((kart: StandardKartController, reason: EKartRescueReason, departure: BABYLON.Vector3) => IKartRescuePlacement | null) | null;
+    readonly onKartRescuedObservable: BABYLON.Observable<IKartRescueEvent>;
+    private readonly recoveryWatch;
+    private contactSeconds;
+    private static readonly CONTACT_SUPPORT_SECONDS;
+    private readonly recoveryVelocity;
+    private rescueReason;
+    private rescueHeld;
+    private lastGroundedAntiGravity;
+    private courseMemory;
+    private static courseMemoryKeyCount;
+    private readonly courseMemoryKey;
+    private readonly lastGroundedPosition;
+    private readonly lastGroundedUp;
+    private readonly rescueLiftStep;
+    requestRescue(reason: EKartRescueReason): boolean;
+    getRescueReason(): EKartRescueReason | null;
+    setRescueFloor(floorY: number | null): void;
+    getLastGroundedPosition(): BABYLON.Vector3;
+    getLastGroundedUp(): BABYLON.Vector3;
+    private holdForRescue;
+    private placeRescuedKart;
+    private restoreAntiGravityAt;
+    private getCourseMemory;
+    private tickRecoveryWatch;
+    private measureStallSpeed;
+    stuckRecoveryDelay: number;
+    stuckRecoveryLift: number;
+    protected stuckTimer: number;
+    private readonly stuckRecoveryPosition;
+    private readonly stuckRecoveryRotation;
+    protected hasGroundlessExcuse(): boolean;
+    protected tickStuckRecovery(dt: number): void;
+    protected recoverFromStuck(): void;
+    protected onStuckRecovery(): void;
+    getStuckTime(): number;
+    clearTransientState(): void;
+    isPlayerBeingMoved(): boolean;
+    private performRespawnTeleport;
+    private tickRespawn;
+    private finishRescue;
+    protected onRecoveryVolume(tag: string): void;
+    setRespawnPoint(position: BABYLON.Vector3, rotation: BABYLON.Quaternion): void;
+    private commitVelocity;
+    private updateGroundRayDistance;
+    protected isRoadNormal(hitNormal: BABYLON.Vector3): boolean;
+    private probeGround;
+    protected latchAntiGravityOnBank(hitNormal: BABYLON.Vector3, hitBody: BABYLON.PhysicsBody | null | undefined): boolean;
+    private probeDriftEntryGround;
+    private alignToGroundNormal;
+    protected levelAirborneAttitude(dt: number): void;
+    protected seekAntiGravitySurface(deltaSeconds: number): void;
+    protected stepKartState(): void;
+    protected fixedKartState(): void;
+    protected destroyKartState(): void;
+    drive(throttle: number, steering: number, drifting: boolean, trick?: boolean, pitch?: number, braking?: boolean): void;
+    readonly onKartHitObservable: BABYLON.Observable<IKartHitEvent>;
+    readonly onKartBumpObservable: BABYLON.Observable<IKartBumpEvent>;
+    readonly externalVelocity: BABYLON.Vector3;
+    private readonly hitState;
+    private activePushes;
+    private wallBounceSpeed;
+    private readonly wallBounceNormal;
+    private readonly wallTravelDirection;
+    private readonly wallEaseNormal;
+    private readonly wallEaseInverseRotation;
+    private readonly wallEaseRotation;
+    private readonly surfaceContacts;
+    private surfaceContactObserver;
+    private readonly contactNormalTowardKart;
+    private sweepShape;
+    private sweepLayerMask;
+    private readonly sweepTravel;
+    private readonly sweepStart;
+    private readonly sweepEnd;
+    private readonly sweepInputResult;
+    private readonly sweepHitResult;
+    private ledgeAheadMountable;
+    private blockedAheadBody;
+    private readonly ledgeTouchTravelDirection;
+    private readonly ledgeRoomStart;
+    private readonly ledgeRoomEnd;
+    private readonly ledgeRoomInputResult;
+    private readonly ledgeRoomHitResult;
+    private committedNoseSpeed;
+    private readonly movingRoadVelocity;
+    private contactClockSeconds;
+    private readonly wallTouchSeconds;
+    private bumpCooldownRemaining;
+    private antiGravityBumpBoostCountdown;
+    private autoDrive;
+    private autoDriveRemaining;
+    private hurtActive;
+    private reverseSkidArmed;
+    private reverseSkidActive;
+    private reversingActive;
+    private static readonly WALL_SWEEP_LIFT;
+    private static readonly WALL_SWEEP_MARGIN;
+    private static readonly WALL_SWEEP_MIN_SPEED;
+    private static readonly LEDGE_ROOM_CLEARANCE;
+    private static readonly LEDGE_ROOM_MARGIN;
+    private static readonly ANTIGRAVITY_BUMP_BOOST_DELAY;
+    private static readonly ANTIGRAVITY_BUMP_BOOST_BELOW;
+    private static readonly AUTO_DRIVE_TURN_DIVIDER;
+    static readonly BULLET_GROUND_RAY_DIST: number;
+    private static readonly REVERSE_SKID_ARM_SPEED;
+    private static readonly REVERSE_SKID_STALL_SPEED;
+    private static readonly REVERSE_SKID_MAX_SPEED;
+    private static readonly WALL_REARM_SECONDS;
+    hitByBanana(): boolean;
+    hitByShell(): boolean;
+    hitByExplosion(): boolean;
+    startStar(seconds?: number): void;
+    startAutoDrive(options: IKartAutoDriveOptions): void;
+    stopAutoDrive(): void;
+    hasStar(): boolean;
+    isAutoDriving(): boolean;
+    isSpunOut(): boolean;
+    isInvulnerable(): boolean;
+    isReverseSkidding(): boolean;
+    isReversing(): boolean;
+    applyPush(force: BABYLON.Vector3, seconds: number): void;
+    limitSpeed(maxSpeed: number): void;
+    setRaceStarted(started: boolean): void;
+    private readonly steeringYawRateState;
+    getSteeringYawRate(): number;
+    getHitState(): KartHitState;
+    private landHit;
+    private applyAutoDriveInputs;
+    private tickAutoDrive;
+    private tickAntiGravityBumpBoost;
+    private stepPushes;
+    private updateReverseSkid;
+    private updateReversing;
+    private onImpactContact;
+    private attachSurfaceContacts;
+    private onBodyContact;
+    private contactStepMinUpDot;
+    private armLedgeAtTouchedCorner;
+    private isTouchedLedgeMountable;
+    private isStaticScenery;
+    private static belongsToRemoteKart;
+    private hitWall;
+    private easeHeadingAlongWall;
+    private keepNoseSpeedOnMovingRoad;
+    private isOnMovingRoad;
+    private fadeWallBounce;
+    private steeringBandSpeed;
+    private limitApproachToWallAhead;
+    private hasRoomOnLedge;
+    private getSweepLayerMask;
+    private getSweepShape;
+    private getSweepRadius;
+    private clearWallContacts;
+    private bumpKart;
+    private playBumpReaction;
+    private findKartPartner;
+    getCurrentSpeed(): number;
+    getThrottleInput(): number;
+    isBrakeHeld(): boolean;
+    private isAccelerateHeld;
+    private isBrakeInputHeld;
+    protected isDriftBrakeActive(): boolean;
+    get steerInput(): number;
+    getRealCurrentSpeed(): number;
+    getDriftState(): EKartDriftState;
+    getDriftHopCount(): number;
+    getDriftTime(): number;
+    getDriftTier(): number;
+    getDriftTierTimes(): number[];
+    getRotateStrength(): number;
+    getBoostTime(): number;
+    isBoosting(): boolean;
+    getMaxSpeed(): number;
+    getLaunchCharge(): number;
+    getSparkColor(): string | null;
+    getYawRate(): number;
+    getSlipAngle(): number;
+    getGroundNormal(): BABYLON.Vector3;
+    isGrounded(): boolean;
+    isAirborne(): boolean;
+    isProbeGrounded(): boolean;
+    getGroundDistance(): number;
+    getGroundRayDistance(): number;
+    isDrifting(): boolean;
+    getDriftDirection(): number;
+    getDriftLatchTime(): number;
+    isDriftLatched(): boolean;
+    isGliding(): boolean;
+    getGlidingTime(): number;
+    isGliderTrick(): boolean;
+    getGliderOpenDelay(): number;
+    getGliderPitch(): number;
+    getGliderRoll(): number;
+    isArcadeGlider(): boolean;
+    getGliderSlope(): number;
+    getGliderSinkTarget(): number;
+    getGlideAngles(): {
+        x: number;
+        z: number;
+    };
+    getGlideAngleX(): number;
+    getGlideAngleZ(): number;
+    getGliderImpulseTime(): number;
+    isAntiGravity(): boolean;
+    getAntiGravityRotAmountX(): number;
+    getAntiGravityRotAmountZ(): number;
+    isAntiGravityCamRotate(): boolean;
+    isAntiGravityExiting(): boolean;
+    getAntiGravityVolumeCount(): number;
+    isJumpPanelling(): boolean;
+    getJumpPanelForce(): number;
+    getJumpPanelRotateTime(): number;
+    isTricking(): boolean;
+    getTrickTime(): number;
+    isTrickArmed(): boolean;
+    isTrickPending(): boolean;
+    getWheelSteer(): number;
+    getWheelSpin(): number;
+    getWheelAntiGravity(): number;
+    isOnDirt(): boolean;
+    getBoostGrantCount(): number;
+    getLastBoostSource(): EKartBoostSource;
+    isFellInWater(): boolean;
+    isRaceCompleted(): boolean;
+    isRaceStarted(): boolean;
+}
+export interface IKartEffectsTarget {
+    transform?: BABYLON.TransformNode;
+    getDriftState(): number;
+    getDriftTime(): number;
+    getDriftTierTimes?(): number[];
+    isDriftLatched(): boolean;
+    getDriftDirection(): number;
+    getBoostTime(): number;
+    getBoostGrantCount?(): number;
+    getLastBoostSource?(): number;
+    isBoosting(): boolean;
+    isAntiGravity(): boolean;
+    isTricking(): boolean;
+    isGrounded(): boolean;
+    sparkTier1Color?: string;
+    sparkTier2Color?: string;
+    sparkTier3Color?: string;
+    antiGravityTireColor?: string;
+    hasUnderwaterHandling?(): boolean;
+    Is_Dirt_Track?: boolean;
+    getRealCurrentSpeed?(): number;
+    isDrifting?(): boolean;
+    isGliding?(): boolean;
+    isJumpPanelling?(): boolean;
+    getThrottleInput?(): number;
+    isBrakeHeld?(): boolean;
+    isAutoDriving?(): boolean;
+    useBulletBillModel?: boolean;
+    isReverseSkidding?(): boolean;
+    hasStar?(): boolean;
+    RACE_STARTED?: boolean;
+}
+export interface IKartEmitterGroup {
+    name: string;
+    mount: BABYLON.TransformNode | null;
+    systems: ShurikenParticles[];
+    playing: boolean;
+    placeholder: boolean;
+    simulationSpace: number;
+}
+export declare class StandardKartEffects extends ScriptComponent {
+    private static readonly CURVE_MODE_CONSTANT;
+    private static readonly CURVE_MODE_CURVE;
+    private static readonly CURVE_MODE_TWO_CURVES;
+    private static readonly CURVE_MODE_TWO_CONSTANTS;
+    kart: IKartEffectsTarget;
+    mountNode: BABYLON.TransformNode;
+    modelNodeName: string;
+    effectsEnabled: boolean;
+    sparksEnabled: boolean;
+    driftDustEnabled: boolean;
+    driftDustWholeDrift: boolean;
+    driftDustEmissionScale: number;
+    driftDustSizeScale: number;
+    driftDustLifetimeScale: number;
+    boostBurstEnabled: boolean;
+    boostFlamesEnabled: boolean;
+    antiGravSpinEnabled: boolean;
+    tireGlowEnabled: boolean;
+    antiGravityTireColor: string;
+    protected tireGlow: KartTireGlow;
+    trickParticlesEnabled: boolean;
+    groundLandEnabled: boolean;
+    createPlaceholderEmitters: boolean;
+    driftPSNodeName: string;
+    rightWheelDriftNodeName: string;
+    leftWheelDriftNodeName: string;
+    driftDustLeftNodeName: string;
+    driftDustRightNodeName: string;
+    boostBurstNodeName: string;
+    boostPSNodeName: string;
+    antiGravSpinNodeName: string;
+    trickParticlesNodeName: string;
+    groundLandNodeName: string;
+    dustNodeName: string;
+    starNodeName: string;
+    exhaustNodeName: string;
+    startDustNodeName: string;
+    sparkTier1Color: string;
+    sparkTier2Color: string;
+    sparkTier3Color: string;
+    protected readonly groups: Map<string, IKartEmitterGroup>;
+    protected activeSparkColor: string;
+    protected lastBoostTime: number;
+    protected lastBoostGrantCount: number;
+    protected boostBurstCount: number;
+    protected antiGravSpinTimer: number;
+    protected antiGravSpinArmed: boolean;
+    protected lastAntiGravity: boolean;
+    protected lastTricking: boolean;
+    protected lastGrounded: boolean;
+    private readonly scratchColor;
+    protected awake(): void;
+    protected start(): void;
+    protected update(): void;
+    protected destroy(): void;
+    protected awakeEffectsState(): void;
+    protected initEffectsState(): void;
+    protected destroyEffectsState(): void;
+    protected updateEffectsState(): void;
+    protected tickTrackDust(): void;
+    protected isDirtTrackDustDue(): boolean;
+    protected isKartBraking(): boolean;
+    protected tickStartDust(): void;
+    protected tickStar(): void;
+    protected tickDriftEffects(): void;
+    protected tickBoostEffects(): void;
+    protected isFlameRideRunning(): boolean;
+    protected tickAntiGravSpin(dt: number): void;
+    protected tickTireGlow(deltaSeconds: number): void;
+    protected tickOneShots(): void;
+    protected playGroup(name: string): void;
+    protected stopGroup(name: string): void;
+    private static AnySystemPlaying;
+    protected restartGroup(name: string): void;
+    protected stopAllGroups(): void;
+    protected applySparkColor(hex: string): void;
+    protected writeGroupColor(name: string, hex: string): void;
+    protected resolveMountNode(): BABYLON.TransformNode;
+    protected resolveSimulationSpace(group: IKartEmitterGroup, kind: string): number;
+    protected findChildNode(name: string): BABYLON.TransformNode;
+    protected resolveKartRoot(): BABYLON.TransformNode;
+    protected buildGroups(): void;
+    protected registerGroup(key: string, nodeName: string, parent: BABYLON.TransformNode, count: number, offset: BABYLON.Vector3, kind: string, placeholderAllowed?: boolean): void;
+    protected scaleDriftDustSystems(groupName: string): void;
+    protected scaleDustStartSize(main: IParticleMainModule, particles: BABYLON.ParticleSystem, sizeScale: number): void;
+    protected scaleDustStartLifetime(main: IParticleMainModule, particles: BABYLON.ParticleSystem, lifetimeScale: number): void;
+    protected static ScaleMinMaxCurve(curve: IParticleMinMaxCurve, factor: number): boolean;
+    protected findNamedChildOf(parent: BABYLON.TransformNode, name: string): BABYLON.TransformNode;
+    protected collectParticleComponents(node: BABYLON.TransformNode): ShurikenParticles[];
+    protected createMountNode(name: string, offset: BABYLON.Vector3): BABYLON.TransformNode;
+    protected createPlaceholderSystems(mount: BABYLON.TransformNode, nodeName: string, count: number, kind: string): ShurikenParticles[];
+    protected static Curve(value: number): any;
+    protected static PlaceholderProperties(kind: string, index: number): any;
+    protected static SparkProperties(index: number): any;
+    protected static DustProperties(): any;
+    protected static BurstProperties(): any;
+    protected static FlameProperties(): any;
+    protected static SpinProperties(): any;
+    isGroupPlaying(name: string): boolean;
+    getGroupSystemCount(name: string): number;
+    isGroupPlaceholder(name: string): boolean;
+    getGroupNames(): string[];
+    getActiveSparkColor(): string;
+    getBoostBurstCount(): number;
+    getAntiGravSpinTimer(): number;
+    static SourceBursts(source: number): boolean;
+    static HexToColor4(hex: string, result: BABYLON.Color4): BABYLON.Color4;
+}
 export declare class CheckpointManager extends ScriptComponent {
     private checkPointList;
     private checkPointCount;
@@ -110,116 +2270,6 @@ export declare class RaceTrackManager extends ScriptComponent {
     static GetLeaderboardPositionList(): PlayerRaceStats[];
     private static SortLeaderboardPositionList;
 }
-export declare class RemoteCarController extends ScriptComponent {
-    private static ShowSensorLines;
-    centerOfMass: number;
-    burnoutWheelPitch: number;
-    linkTrackManager: boolean;
-    playVehicleSounds: boolean;
-    smokeTexture: BABYLON.Texture;
-    skidThreashold: number;
-    smokeIntensity: number;
-    wheelDrawVelocity: number;
-    smokeOpacity: number;
-    smokeDonuts: number;
-    private steeringWheelHub;
-    private steeringWheelAxis;
-    private maxSteeringAngle;
-    private maxSteeringSpeed;
-    private _animator;
-    private _engineAudioSource;
-    private _skidAudioSource;
-    private brakeLightsMesh;
-    private brakeLightsTrans;
-    private reverseLightsMesh;
-    private reverseLightsTrans;
-    private frontLeftWheelTrans;
-    private frontRightWheelTrans;
-    private backLeftWheelTrans;
-    private backRightWheelTrans;
-    private frontLeftWheelMesh;
-    private frontRightWheelMesh;
-    private backLeftWheelMesh;
-    private backRightWheelMesh;
-    private frontLeftWheelEmitter;
-    private frontRightWheelEmitter;
-    private backLeftWheelEmitter;
-    private backRightWheelEmitter;
-    private frontLeftWheelParticle;
-    private frontRightWheelParticle;
-    private backLeftWheelParticle;
-    private backRightWheelParticle;
-    private frontLeftContact;
-    private frontRightContact;
-    private rearLeftContact;
-    private rearRightContact;
-    private frontLeftContactTag;
-    private frontRightContactTag;
-    private rearLeftContactTag;
-    private rearRightContactTag;
-    private frontLeftContactPoint;
-    private frontRightContactPoint;
-    private rearLeftContactPoint;
-    private rearRightContactPoint;
-    private frontLeftContactNormal;
-    private frontRightContactNormal;
-    private rearLeftContactNormal;
-    private rearRightContactNormal;
-    private startRaycastPosition;
-    private endRaycastPosition;
-    private smokeIntensityFactor;
-    private downDirection;
-    private downDistance;
-    private lastPitch;
-    private lastBrake;
-    private lastReverse;
-    private lastBurnout;
-    private lastSteering;
-    private lastSKID_FL;
-    private lastSKID_FR;
-    private lastSKID_RL;
-    private lastSKID_RR;
-    private lastSPIN_FL;
-    private lastSPIN_FR;
-    private lastSPIN_RL;
-    private lastSPIN_RR;
-    private PITCH_FL;
-    private PITCH_FR;
-    private PITCH_RL;
-    private PITCH_RR;
-    private WHEEL_SKID_PITCH;
-    getFrontLeftWheelContact(): boolean;
-    getFrontRightWheelContact(): boolean;
-    getRearLeftWheelContact(): boolean;
-    getRearRightWheelContact(): boolean;
-    getFrontLeftWheelContactTag(): string;
-    getFrontRightWheelContactTag(): string;
-    getRearLeftWheelContactTag(): string;
-    getRearRightWheelContactTag(): string;
-    getFrontLeftWheelContactPoint(): BABYLON.Vector3;
-    getFrontRightWheelContactPoint(): BABYLON.Vector3;
-    getRearLeftWheelContactPoint(): BABYLON.Vector3;
-    getRearRightWheelContactPoint(): BABYLON.Vector3;
-    getFrontLeftWheelContactNormal(): BABYLON.Vector3;
-    getFrontRightWheelContactNormal(): BABYLON.Vector3;
-    getRearLeftWheelContactNormal(): BABYLON.Vector3;
-    getRearRightWheelContactNormal(): BABYLON.Vector3;
-    protected m_frontLeftWheelSkid: number;
-    protected m_frontRightWheelSkid: number;
-    protected m_backLeftWheelSkid: number;
-    protected m_backRightWheelSkid: number;
-    protected m_velocityOffset: BABYLON.Vector3;
-    protected m_linearVelocity: BABYLON.Vector3;
-    protected m_lastPosition: BABYLON.Vector3;
-    protected m_positionCenter: BABYLON.Vector3;
-    protected m_scaledVelocity: number;
-    protected awake(): void;
-    protected start(): void;
-    protected update(): void;
-    protected destroy(): void;
-    protected updateVehicleProperties(): void;
-    private createSmokeParticleSystem;
-}
 export declare class SideCameraController extends ScriptComponent {
     private _camera;
     private _adt;
@@ -389,10 +2439,6 @@ export declare class StandardCarController extends ScriptComponent {
     private BACK_RIGHT;
     private WHEEL_SKID_PITCH;
     private POWER_BOOST_PITCH;
-    private SPIN_FL_Rotation;
-    private SPIN_FR_Rotation;
-    private SPIN_RL_Rotation;
-    private SPIN_RR_Rotation;
     isBraking(): boolean;
     isBoosting(): boolean;
     private allowRollingReverseBurnout;
@@ -563,7 +2609,6 @@ export declare class StandardCarController extends ScriptComponent {
     powerBooster: boolean;
     linkTrackManager: boolean;
     playVehicleSounds: boolean;
-    postNetworkAttributes: boolean;
     wheelDriveType: number;
     gearBoxMultiplier: number;
     currentPitchScale: number;
@@ -1026,23 +3071,6 @@ export declare class VehicleInputController extends ScriptComponent {
     protected generateRandonNumber(min: number, max: number, decimals?: number): number;
     protected destroyVehicleController(): void;
 }
-export declare class VehicleNetworkLabel extends ScriptComponent {
-    label: BABYLON.GUI.TextBlock;
-    rect: BABYLON.GUI.Rectangle;
-    autoCreate: boolean;
-    offsetX: number;
-    offsetY: number;
-    labelColor: BABYLON.Color3;
-    borderColor: BABYLON.Color3;
-    backgroundColor: BABYLON.Color3;
-    labelCreated: boolean;
-    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
-    protected update(): void;
-    createLabel(name: string): void;
-    protected destroy(): void;
-    private static AdvDynamicTexture;
-    static GetFullscreenUI(scene: BABYLON.Scene, sampling?: number): BABYLON.GUI.AdvancedDynamicTexture;
-}
 export declare class DoubleSided extends CustomShaderMaterial {
     constructor(name: string, scene: BABYLON.Scene);
     awake(): void;
@@ -1066,6 +3094,102 @@ export declare class VertexSplatPlugin extends CustomShaderMaterialPlugin {
     prepareDefines(defines: BABYLON.MaterialDefines, scene: BABYLON.Scene, mesh: BABYLON.AbstractMesh): void;
     bindForSubMesh(uniformBuffer: BABYLON.UniformBuffer, scene: BABYLON.Scene, engine: BABYLON.AbstractEngine, subMesh: BABYLON.SubMesh): void;
 }
+export declare class DefaultCameraSystem extends ScriptComponent {
+    protected static PlayerOneCamera: BABYLON.FreeCamera;
+    protected static PlayerTwoCamera: BABYLON.FreeCamera;
+    protected static PlayerThreeCamera: BABYLON.FreeCamera;
+    protected static PlayerFourCamera: BABYLON.FreeCamera;
+    protected static XRExperienceHelper: BABYLON.WebXRDefaultExperience;
+    private static multiPlayerView;
+    private static multiPlayerCount;
+    private static multiPlayerCameras;
+    private static stereoCameras;
+    private static startupMode;
+    private static cameraReady;
+    private static cameraInstance;
+    static IsCameraSystemReady(): boolean;
+    static OnXRExperienceHelperObservable: any;
+    static FOLLOW_SPEED: number;
+    private mainCamera;
+    private cameraType;
+    private cameraInertia;
+    private cameraController;
+    private immersiveOptions;
+    private arcRotateConfig;
+    private multiPlayerSetup;
+    private fullScreenToggle;
+    private setPointerLock;
+    private setCameraTarget;
+    private setSpatialAudio;
+    protected m_cameraRig: BABYLON.TargetCamera;
+    isMainCamera(): boolean;
+    getCameraType(): number;
+    getTargetTransform(): BABYLON.TransformNode;
+    setTargetTransform(target: BABYLON.TransformNode): void;
+    enableSpatialAudio(value: boolean): void;
+    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+    protected awake(): void;
+    protected start(): void;
+    protected update(): void;
+    protected destroy(): void;
+    protected awakeCameraSystemState(): void;
+    protected startCameraSystemState(): Promise<void>;
+    protected updateCameraSystemState(): void;
+    protected cleanCameraSystemState(): void;
+    protected destroyCameraSystemState(): void;
+    targetCameraOffset: BABYLON.Vector3;
+    getCameraPivotPosition(): BABYLON.Vector3;
+    getCameraPivotRotation(): BABYLON.Quaternion;
+    getCameraBoomNode(): BABYLON.TransformNode;
+    getCameraTransform(): BABYLON.TransformNode;
+    private cameraNode;
+    private cameraPivot;
+    private cameraDistance;
+    private cameraPivotOffset;
+    private cameraBoomPosition;
+    private dollyDirection;
+    private rotationEulers;
+    private scaledCamDirection;
+    private scaledMaxDirection;
+    private parentNodePosition;
+    private maximumCameraPos;
+    private cameraRaycastShape;
+    private targetRotationVector;
+    private resetCameraRotation;
+    private updateCameraController;
+    getBoomArmMaxDistance(): number;
+    setBoomArmMaxDistance(distance: number): void;
+    setSmoothBoomArmLength(length: number, speed: number, updateMaxDistance?: boolean): void;
+    private smoothBoomArmLength;
+    private smoothBoomArmSpeed;
+    private updateSmoothBoomArmLength;
+    static EnableTracking(value: boolean): void;
+    static IsTrackingEnabled(): boolean;
+    static SetAutoUpdate(value: boolean): void;
+    static IsAutoUpdateEnabled(): boolean;
+    static GetFollowTarget(): BABYLON.TransformNode;
+    static SetFollowTarget(target: BABYLON.TransformNode): void;
+    static ResetFollowTarget(): void;
+    static UpdateFollowTarget(): void;
+    static GetWebXR(): BABYLON.WebXRDefaultExperience;
+    static IsInWebXR(): boolean;
+    private static SetupNavigationWebXR;
+    static GetMainCamera(scene: BABYLON.Scene, detach?: boolean): BABYLON.FreeCamera;
+    static GetPlayerCamera(scene: BABYLON.Scene, player?: PlayerNumber, detach?: boolean): BABYLON.FreeCamera;
+    static GetCameraTransform(scene: BABYLON.Scene, player?: PlayerNumber): BABYLON.TransformNode;
+    static IsStereoCameras(): boolean;
+    static IsMultiPlayerView(): boolean;
+    static GetMultiPlayerCount(): number;
+    static ActivateMultiPlayerCameras(scene: BABYLON.Scene): boolean;
+    static DisposeMultiPlayerCameras(): void;
+    static SetMultiPlayerViewLayout(scene: BABYLON.Scene, totalNumPlayers: number): boolean;
+}
+export interface IEditorArcRtotate {
+    alpha: number;
+    beta: number;
+    radius: number;
+    target: IUnityVector3;
+}
 export declare class DebugInformation extends ScriptComponent {
     static GetVersion(): string;
     private keys;
@@ -1182,6 +3306,641 @@ export declare class MobileShadowMaterial extends ScriptComponent {
     protected awake(): void;
     protected destroy(): void;
 }
+export declare class RemotePlayerController extends ScriptComponent {
+    updateStateParams: boolean;
+    smoothMotionTime: number;
+    smoothInputVectors: boolean;
+    private animator;
+    private animationStateParams;
+    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+    protected awake(): void;
+    protected update(): void;
+    protected destroy(): void;
+    private attachAnimationController;
+    private validateAnimationStateParams;
+}
+export declare class StandardPlayerController extends ScriptComponent {
+    static MIN_VERTICAL_VELOCITY: number;
+    static MIN_GROUND_DISTANCE: number;
+    static MIN_MOVE_EPSILON: number;
+    static MIN_TIMER_OFFSET: number;
+    static MIN_SLOPE_LIMIT: number;
+    static PLAYER_HEIGHT: string;
+    enableInput: boolean;
+    attachCamera: boolean;
+    rotateCamera: boolean;
+    mouseWheel: boolean;
+    toggleView: boolean;
+    freeLooking: boolean;
+    requireSprintButton: boolean;
+    gravitationalForce: number;
+    minFallVelocity: number;
+    verticalStepSpeed: number;
+    minStepUpHeight: number;
+    rigidBodyMass: number;
+    airbornTimeout: number;
+    maxAngle: number;
+    speedFactor: number;
+    rootMotion: boolean;
+    moveSpeed: number;
+    walkSpeed: number;
+    lookSpeed: number;
+    jumpSpeed: number;
+    jumpDelay: number;
+    eyesHeight: number;
+    pivotHeight: number;
+    maxDistance: number;
+    scrollSpeed: number;
+    topLookLimit: number;
+    downLookLimit: number;
+    lowTurnSpeed: number;
+    highTurnSpeed: number;
+    smoothDampTime: number;
+    smoothInputVectors: boolean;
+    smoothAcceleration: boolean;
+    accelerationSpeed: number;
+    decelerationSpeed: number;
+    avatarSkinTag: string;
+    climbVolumeTag: string;
+    vaultVolumeTag: string;
+    maxHeightRanges: any;
+    useClimbSystem: boolean;
+    distanceFactor: number;
+    cameraSmoothing: number;
+    cameraCollisions: boolean;
+    inputMagnitude: number;
+    analogMovement: boolean;
+    landingEpsilon: number;
+    minimumDistance: number;
+    movementAllowed: boolean;
+    playerInputX: number;
+    playerInputZ: number;
+    playerMouseX: number;
+    playerMouseY: number;
+    runKeyRequired: boolean;
+    buttonRun: number;
+    keyboardRun: number;
+    buttonJump: number;
+    keyboardJump: number;
+    buttonCamera: number;
+    keyboardCamera: number;
+    postNetworkAttributes: boolean;
+    playerNumber: PlayerNumber;
+    boomPosition: BABYLON.Vector3;
+    airbornVelocity: BABYLON.Vector3;
+    movementVelocity: BABYLON.Vector3;
+    targetCameraOffset: BABYLON.Vector3;
+    isAnimationEnabled(): boolean;
+    isRunButtonPressed(): boolean;
+    isJumpButtonPressed(): boolean;
+    getPlayerJumped(): boolean;
+    getPlayerJumping(): boolean;
+    getPlayerFalling(): boolean;
+    getPlayerSliding(): boolean;
+    getPlayerGrounded(): boolean;
+    getFallTriggered(): boolean;
+    getMovementSpeed(): number;
+    getCameraBoomNode(): BABYLON.TransformNode;
+    getCameraTransform(): BABYLON.TransformNode;
+    getAnimator(): Animator;
+    getVerticalVelocity(): number;
+    getCharacterController(): CharacterController;
+    getPlayerLookRotation(): BABYLON.Vector3;
+    getPlayerMoveDirection(): PlayerMoveDirection;
+    getInputMovementVector(): BABYLON.Vector3;
+    getInputMagnitudeValue(): number;
+    getCameraPivotPosition(): BABYLON.Vector3;
+    getCameraPivotRotation(): BABYLON.Quaternion;
+    rayClimbOffset: number;
+    rayClimbLength: number;
+    getClimbContact(): boolean;
+    getClimbContactNode(): BABYLON.TransformNode;
+    getClimbContactPoint(): BABYLON.Vector3;
+    getClimbContactAngle(): number;
+    getClimbContactNormal(): BABYLON.Vector3;
+    getClimbContactDistance(): number;
+    canClimbObstaclePredicate: (action: number) => boolean;
+    rayHeightOffset: number;
+    rayHeightLength: number;
+    getHeightContact(): boolean;
+    getHeightContactNode(): BABYLON.TransformNode;
+    getHeightContactPoint(): BABYLON.Vector3;
+    getHeightContactAngle(): number;
+    getHeightContactNormal(): BABYLON.Vector3;
+    getHeightContactDistance(): number;
+    private abstractMesh;
+    private cameraDistance;
+    private forwardCamera;
+    private avatarRadius;
+    private groundingObject;
+    private groundingCallback;
+    private dollyDirection;
+    private cameraEulers;
+    private rotationEulers;
+    private cameraPivotOffset;
+    private cameraForwardVector;
+    private cameraRightVector;
+    private desiredForwardVector;
+    private desiredRightVector;
+    private lastRotationQuaternion;
+    private scaledCamDirection;
+    private scaledMaxDirection;
+    private parentNodePosition;
+    private maximumCameraPos;
+    private tempWorldPosition;
+    private cameraRaycastShape;
+    private defaultRaycastGroup;
+    private defaultRaycastMask;
+    private cameraRaycastMask;
+    private avatarSkins;
+    private cameraNode;
+    private cameraPivot;
+    private navigationAgent;
+    private characterController;
+    private verticalVelocity;
+    private smoothMotionSpeed;
+    private movementSpeed;
+    private isRunPressed;
+    private isJumpPressed;
+    private isCharacterSliding;
+    private isCharacterFalling;
+    private isCharacterGrounded;
+    private isCharacterFallTriggered;
+    private isCharacterJumpFrame;
+    private isCharacterJumping;
+    private isCharacterLanding;
+    private isCharacterRising;
+    private isCharacterNavigating;
+    private navigationAngularSpeed;
+    private updateStateParams;
+    private animationStateParams;
+    private sphereCollisionShape;
+    private hasGroundedContact;
+    private showDebugColliders;
+    private colliderVisibility;
+    private colliderRenderGroup;
+    private groundCheckDistance;
+    private deltaTime;
+    private minJumpTimer;
+    private delayJumpTimer;
+    private playerControl;
+    private canPlayerJump;
+    private animator;
+    private lastJumpVelocity;
+    private inputMovementVector;
+    private playerLookRotation;
+    private playerRotationVector;
+    private playerMovementVelocity;
+    private playerRotationQuaternion;
+    private playerMoveDirection;
+    private forwardDirection;
+    private downDirection;
+    private climbContact;
+    private climbContactNode;
+    private climbContactAngle;
+    private climbContactPoint;
+    private climbContactNormal;
+    private climbContactDistance;
+    private climbSensorLine;
+    private offsetClimbRaycastPosition;
+    private startClimbRaycastPosition;
+    private endClimbRaycastPosition;
+    private heightContact;
+    private heightContactNode;
+    private heightContactAngle;
+    private heightContactPoint;
+    private heightContactNormal;
+    private heightContactDistance;
+    private heightSensorLine;
+    private offsetHeightRaycastPosition;
+    private startHeightRaycastPosition;
+    private endHeightRaycastPosition;
+    protected m_velocityOffset: BABYLON.Vector3;
+    protected m_actualVelocity: BABYLON.Vector3;
+    protected m_linearVelocity: BABYLON.Vector3;
+    protected m_lastPosition: BABYLON.Vector3;
+    protected m_positionCenter: BABYLON.Vector3;
+    protected m_scaledVelocity: number;
+    protected playerDrawVelocity: number;
+    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+    protected awake(): void;
+    protected start(): void;
+    protected after(): void;
+    protected update(): void;
+    protected destroy(): void;
+    onPreUpdateObservable: any;
+    onBeforeMoveObservable: any;
+    onPostUpdateObservable: any;
+    onPlayerInputObservable: any;
+    onPlayerPositionObservable: any;
+    onUpdateActionObservable: any;
+    private animatorMoveObserver;
+    private exportedApplyRootMotion;
+    private readonly rootMotionVelocity;
+    private syncAnimatorMoveTaker;
+    private onAnimatorMove;
+    private isPerformingAction;
+    private isRootMotionAction;
+    private isActionInterruptable;
+    private afterActionHandler;
+    private performActionTimer;
+    private performActionNumber;
+    private playerRotationSpeed;
+    private rotatePlayerTowards;
+    private matchStartTime;
+    private matchTargetTime;
+    private matchTargetOffset;
+    private matchTargetHeight;
+    private lockTargetHeight;
+    private lastStartHeight;
+    private lastTargetHeight;
+    private lastTargetNormal;
+    private lastTargetRotation;
+    private lastDeltaPosition;
+    private lastDeltaRotation;
+    private smoothedPlayerHeight;
+    private readonly playerHeightVelocity;
+    private actionStateHash;
+    private actionStateEntered;
+    getIsPerformingAction(): boolean;
+    getIsRootMotionAction(): boolean;
+    getIsActionInterruptable(): boolean;
+    playActionAnimation(action: number, interruptableAction?: boolean, enableRootMotion?: boolean, afterActionComplete?: () => void): void;
+    resetActionAnimationState(): void;
+    private updateAnimationActionState;
+    private applyActionRootMotion;
+    private applyHeightMatch;
+    private rotateTowardsClimbSurface;
+    setWorldPosition(x: number, y: number, z: number): void;
+    setPlayerControl(mode: PlayerInputControl): void;
+    togglePlayerControl(): void;
+    private showAvatarSkins;
+    attachPlayerCamera(player: PlayerNumber): void;
+    private ikLeftFootTarget;
+    private ikLeftPoleTarget;
+    private ikRightFootTarget;
+    private ikRightPoleTarget;
+    private abstractSkinMesh;
+    private rootBoneTransform;
+    private leftFootTransform;
+    private leftFootPoleOffset;
+    private leftFootMaxAngle;
+    private rightFootTransform;
+    private rightFootPoleOffset;
+    private rightFootMaxAngle;
+    private ikLeftController;
+    private ikRightController;
+    onAnimatorIK: () => void;
+    getPlayerMesh(): BABYLON.AbstractMesh;
+    getRootHipBone(): BABYLON.Bone;
+    getLeftFootBone(): BABYLON.Bone;
+    getRightFootBone(): BABYLON.Bone;
+    getLeftFootTarget(): BABYLON.Mesh;
+    getRightFootTarget(): BABYLON.Mesh;
+    getLeftFootPoleTarget(): BABYLON.Mesh;
+    getRightFootPoleTarget(): BABYLON.Mesh;
+    getRootBoneTransform(): BABYLON.TransformNode;
+    getLeftFootTransform(): BABYLON.TransformNode;
+    getRightFootTransform(): BABYLON.TransformNode;
+    getLeftFootController(): BABYLON.BoneIKController;
+    getRightFootController(): BABYLON.BoneIKController;
+    isGroundedFootIKActive(): boolean;
+    setupBoneControllers(): void;
+    private attachAnimationController;
+    private onAnimatorStateEnter;
+    private onAnimatorStateExit;
+    private onAnimatorIKPass;
+    private updateAnimatorTargetMeshes;
+    enableCharacterController(state: boolean): void;
+    resetPlayerRotation(): void;
+    resetPlayerJumpingState(): void;
+    private awakePlayerController;
+    private startPlayerController;
+    private updatePlayerPosition;
+    private updatePlayerController;
+    private afterPlayerController;
+    private updateCharacterController;
+    private updateCameraController;
+    getBoomArmMaxDistance(): number;
+    setBoomArmMaxDistance(distance: number): void;
+    setSmoothBoomArmLength(length: number, speed: number, updateMaxDistance?: boolean): void;
+    private smoothBoomArmLength;
+    private smoothBoomArmSpeed;
+    private updateSmoothBoomArmLength;
+    private castPhysicsClimbingVolumeRay;
+    private castPhysicsHeightCheckVolumeRay;
+    private getCheckedVerticalVelocity;
+    private destroyPlayerController;
+    private validateAnimationStateParams;
+    static ApplyAnimationStateParamDefaults(params: AnimationStateParams): AnimationStateParams;
+}
+export interface AnimationStateParams {
+    moveDirection: string;
+    inputMagnitude: string;
+    horizontalInput: string;
+    verticalInput: string;
+    mouseXInput: string;
+    mouseYInput: string;
+    heightInput: string;
+    speedInput: string;
+    motionSpeed?: string;
+    jumpFrame: string;
+    jumpState: string;
+    actionState: string;
+    fallingState: string;
+    slidingState: string;
+    groundedState: string;
+}
+export declare enum PlayerInputControl {
+    FirstPersonStrafing = 0,
+    ThirdPersonStrafing = 1
+}
+export declare enum PlayerMoveDirection {
+    Stationary = 0,
+    Forward = 1,
+    ForwardLeft = 2,
+    ForwardRight = 3,
+    Backward = 4,
+    BackwardLeft = 5,
+    BackwardRight = 6,
+    StrafingLeft = 7,
+    StrafingRight = 8
+}
+export declare enum ActionAnimationType {
+    Neutral = 0,
+    StepUp = 1,
+    JumpUp = 2,
+    ClimbUp = 3,
+    VaultOver = 4
+}
+export declare class ThirdPersonPlayerController extends ScriptComponent {
+    static MIN_VERTICAL_VELOCITY: number;
+    static MIN_GROUND_DISTANCE: number;
+    static MIN_MOVE_EPSILON: number;
+    static MIN_TIMER_OFFSET: number;
+    static MIN_SLOPE_LIMIT: number;
+    static PLAYER_HEIGHT: string;
+    enableInput: boolean;
+    attachCamera: boolean;
+    mouseWheel: boolean;
+    requireSprintButton: boolean;
+    gravitationalForce: number;
+    minFallVelocity: number;
+    verticalStepSpeed: number;
+    minStepUpHeight: number;
+    rigidBodyMass: number;
+    airbornTimeout: number;
+    maxAngle: number;
+    speedFactor: number;
+    rootMotion: boolean;
+    moveSpeed: number;
+    walkSpeed: number;
+    jumpSpeed: number;
+    jumpDelay: number;
+    lowTurnSpeed: number;
+    highTurnSpeed: number;
+    smoothDampTime: number;
+    smoothInputVectors: boolean;
+    smoothAcceleration: boolean;
+    accelerationSpeed: number;
+    decelerationSpeed: number;
+    climbVolumeTag: string;
+    vaultVolumeTag: string;
+    maxHeightRanges: any;
+    useClimbSystem: boolean;
+    distanceFactor: number;
+    inputMagnitude: number;
+    analogMovement: boolean;
+    landingEpsilon: number;
+    minimumDistance: number;
+    movementAllowed: boolean;
+    playerInputX: number;
+    playerInputZ: number;
+    playerMouseX: number;
+    playerMouseY: number;
+    runKeyRequired: boolean;
+    buttonRun: number;
+    keyboardRun: number;
+    buttonJump: number;
+    keyboardJump: number;
+    buttonCamera: number;
+    keyboardCamera: number;
+    postNetworkAttributes: boolean;
+    playerNumber: PlayerNumber;
+    airbornVelocity: BABYLON.Vector3;
+    movementVelocity: BABYLON.Vector3;
+    isAnimationEnabled(): boolean;
+    isRunButtonPressed(): boolean;
+    isJumpButtonPressed(): boolean;
+    getPlayerJumped(): boolean;
+    getPlayerJumping(): boolean;
+    getPlayerFalling(): boolean;
+    getPlayerSliding(): boolean;
+    getPlayerGrounded(): boolean;
+    getFallTriggered(): boolean;
+    getMovementSpeed(): number;
+    getAnimator(): Animator;
+    getVerticalVelocity(): number;
+    getCharacterController(): CharacterController;
+    getPlayerLookRotation(): BABYLON.Vector3;
+    getPlayerMoveDirection(): PlayerMoveDirection;
+    getInputMovementVector(): BABYLON.Vector3;
+    getInputMagnitudeValue(): number;
+    rayClimbOffset: number;
+    rayClimbLength: number;
+    getClimbContact(): boolean;
+    getClimbContactNode(): BABYLON.TransformNode;
+    getClimbContactPoint(): BABYLON.Vector3;
+    getClimbContactAngle(): number;
+    getClimbContactNormal(): BABYLON.Vector3;
+    getClimbContactDistance(): number;
+    canClimbObstaclePredicate: (action: number) => boolean;
+    rayHeightOffset: number;
+    rayHeightLength: number;
+    getHeightContact(): boolean;
+    getHeightContactNode(): BABYLON.TransformNode;
+    getHeightContactPoint(): BABYLON.Vector3;
+    getHeightContactAngle(): number;
+    getHeightContactNormal(): BABYLON.Vector3;
+    getHeightContactDistance(): number;
+    private freeCamera;
+    private cameraForwardVector;
+    private cameraRightVector;
+    private desiredForwardVector;
+    private desiredRightVector;
+    private lastRotationQuaternion;
+    private avatarSkins;
+    private avatarRadius;
+    private navigationAgent;
+    private characterController;
+    private verticalVelocity;
+    private smoothMotionSpeed;
+    private movementSpeed;
+    private isRunPressed;
+    private isJumpPressed;
+    private isCharacterSliding;
+    private isCharacterFalling;
+    private isCharacterGrounded;
+    private isCharacterFallTriggered;
+    private isCharacterJumpFrame;
+    private isCharacterJumping;
+    private isCharacterRising;
+    private isCharacterLanding;
+    private isCharacterNavigating;
+    private navigationAngularSpeed;
+    private updateStateParams;
+    private animationStateParams;
+    private sphereCollisionShape;
+    private hasGroundedContact;
+    private showDebugColliders;
+    private colliderVisibility;
+    private colliderRenderGroup;
+    private groundCheckDistance;
+    private deltaTime;
+    private delayJumpTimer;
+    private canPlayerJump;
+    private animator;
+    private lastJumpVelocity;
+    private inputMovementVector;
+    private playerLookRotation;
+    private playerMovementVelocity;
+    private playerRotationQuaternion;
+    private playerMoveDirection;
+    private forwardDirection;
+    private downDirection;
+    private climbContact;
+    private climbContactNode;
+    private climbContactAngle;
+    private climbContactPoint;
+    private climbContactNormal;
+    private climbContactDistance;
+    private climbSensorLine;
+    private offsetClimbRaycastPosition;
+    private startClimbRaycastPosition;
+    private endClimbRaycastPosition;
+    private heightContact;
+    private heightContactNode;
+    private heightContactAngle;
+    private heightContactPoint;
+    private heightContactNormal;
+    private heightContactDistance;
+    private heightSensorLine;
+    private offsetHeightRaycastPosition;
+    private startHeightRaycastPosition;
+    private endHeightRaycastPosition;
+    protected m_velocityOffset: BABYLON.Vector3;
+    protected m_actualVelocity: BABYLON.Vector3;
+    protected m_linearVelocity: BABYLON.Vector3;
+    protected m_lastPosition: BABYLON.Vector3;
+    protected m_positionCenter: BABYLON.Vector3;
+    protected m_scaledVelocity: number;
+    protected playerDrawVelocity: number;
+    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+    protected awake(): void;
+    protected start(): void;
+    protected after(): void;
+    protected update(): void;
+    protected destroy(): void;
+    boomPosition: BABYLON.Vector3;
+    onPreUpdateObservable: any;
+    onBeforeMoveObservable: any;
+    onPostUpdateObservable: any;
+    onPlayerInputObservable: any;
+    onPlayerPositionObservable: any;
+    onUpdateActionObservable: any;
+    onAnimationStateObservable: any;
+    private animatorMoveObserver;
+    private exportedApplyRootMotion;
+    private readonly rootMotionVelocity;
+    private syncAnimatorMoveTaker;
+    private onAnimatorMove;
+    private isPerformingAction;
+    private isRootMotionAction;
+    private isActionInterruptable;
+    private afterActionHandler;
+    private performActionTimer;
+    private performActionNumber;
+    private playerRotationSpeed;
+    private rotatePlayerTowards;
+    private matchStartTime;
+    private matchTargetTime;
+    private matchTargetOffset;
+    private matchTargetHeight;
+    private lockTargetHeight;
+    private lastStartHeight;
+    private lastTargetHeight;
+    private lastTargetNormal;
+    private lastTargetRotation;
+    private lastDeltaPosition;
+    private lastDeltaRotation;
+    private smoothedPlayerHeight;
+    private readonly playerHeightVelocity;
+    private actionStateHash;
+    private actionStateEntered;
+    getIsPerformingAction(): boolean;
+    getIsRootMotionAction(): boolean;
+    getIsActionInterruptable(): boolean;
+    playActionAnimation(action: number, interruptableAction?: boolean, enableRootMotion?: boolean, afterActionComplete?: () => void): void;
+    resetActionAnimationState(): void;
+    private updateAnimationActionState;
+    private applyActionRootMotion;
+    private applyHeightMatch;
+    private rotateTowardsClimbSurface;
+    setWorldPosition(x: number, y: number, z: number): void;
+    private ikLeftFootTarget;
+    private ikLeftPoleTarget;
+    private ikRightFootTarget;
+    private ikRightPoleTarget;
+    private abstractSkinMesh;
+    private rootBoneTransform;
+    private leftFootTransform;
+    private leftFootPoleOffset;
+    private leftFootMaxAngle;
+    private rightFootTransform;
+    private rightFootPoleOffset;
+    private rightFootMaxAngle;
+    private ikLeftController;
+    private ikRightController;
+    onAnimatorIK: () => void;
+    getPlayerMesh(): BABYLON.AbstractMesh;
+    getRootHipBone(): BABYLON.Bone;
+    getLeftFootBone(): BABYLON.Bone;
+    getRightFootBone(): BABYLON.Bone;
+    getLeftFootTarget(): BABYLON.Mesh;
+    getRightFootTarget(): BABYLON.Mesh;
+    getLeftFootPoleTarget(): BABYLON.Mesh;
+    getRightFootPoleTarget(): BABYLON.Mesh;
+    getRootBoneTransform(): BABYLON.TransformNode;
+    getLeftFootTransform(): BABYLON.TransformNode;
+    getRightFootTransform(): BABYLON.TransformNode;
+    getLeftFootController(): BABYLON.BoneIKController;
+    getRightFootController(): BABYLON.BoneIKController;
+    isGroundedFootIKActive(): boolean;
+    setupBoneControllers(): void;
+    private attachAnimationController;
+    private onAnimatorStateEnter;
+    private onAnimatorStateExit;
+    private onAnimatorIKPass;
+    private updateAnimatorTargetMeshes;
+    enableCharacterController(state: boolean): void;
+    resetPlayerJumpingState(): void;
+    private awakePlayerController;
+    private startPlayerController;
+    private updatePlayerPosition;
+    private updatePlayerController;
+    private afterPlayerController;
+    private updateCharacterController;
+    private castPhysicsClimbingVolumeRay;
+    private castPhysicsHeightCheckVolumeRay;
+    private getCheckedVerticalVelocity;
+    private destroyPlayerController;
+    private validateAnimationStateParams;
+    static ApplyAnimationStateParamDefaults(params: AnimationStateParams): AnimationStateParams;
+}
+export declare enum ThirdPersonControl {
+    ThirdPersonTurning = 0,
+    ThirdPersonForward = 1
+}
 export declare class SnapshotManager extends ScriptComponent {
     static IsSnapshotRenderingEnabled(): boolean;
     static EnableSnapshotRendering(): void;
@@ -1260,6 +4019,21 @@ export declare class SoundManager extends ScriptComponent {
     setGroupVolume(volume: number, time?: number): void;
     getAudioSource(name: string): AudioSource;
 }
+export declare class WindowsPlatform {
+    static IsXboxLiveUserSignedIn(systemUser?: Windows.System.User, player?: PlayerNumber): boolean;
+    static XboxLiveUserSignIn(player?: PlayerNumber, oncomplete?: (result: Microsoft.Xbox.Services.System.SignInResult) => void, onerror?: (error: any) => void, onprogress?: (progress: any) => void): void;
+    static XboxLiveUserSilentSignIn(player?: PlayerNumber, oncomplete?: (result: Microsoft.Xbox.Services.System.SignInResult) => void, onerror?: (error: any) => void, onprogress?: (progress: any) => void): Windows.Foundation.Projections.Promise<void>;
+    static XboxLiveUserDialogSignIn(player?: PlayerNumber, oncomplete?: (result: Microsoft.Xbox.Services.System.SignInResult) => void, onerror?: (error: any) => void, onprogress?: (progress: any) => void): Windows.Foundation.Projections.Promise<void>;
+    static LoadXboxLiveUserProfile(player?: PlayerNumber, oncomplete?: (result: Microsoft.Xbox.Services.Social.XboxUserProfile) => void, onerror?: (error: any) => void, onprogress?: (progress: any) => void): Windows.Foundation.Projections.Promise<void>;
+    static GetXboxLiveUser(player?: PlayerNumber): Microsoft.Xbox.Services.System.XboxLiveUser;
+    static GetXboxLiveSystemUser(systemUser: Windows.System.User, player?: PlayerNumber): Microsoft.Xbox.Services.System.XboxLiveUser;
+    static GetXboxLiveUserContext(player?: PlayerNumber): Microsoft.Xbox.Services.XboxLiveContext;
+    static ResetXboxLiveUserContext(player?: PlayerNumber): void;
+    static GetXboxLiveContextProperty(name: any): any;
+    static SetXboxLiveContextProperty(name: any, property: any): void;
+    static ResetXboxLivePropertyContexts(): void;
+    static SetXboxLiveSignOutHandler(handler?: (result: Microsoft.Xbox.Services.System.SignOutCompletedEventArgs) => void): void;
+}
 declare global {
     interface Window {
         PROJECT: Record<string, unknown>;