@babylonjs-toolkit/next 9.28.0 → 9.34.0

package/lib/project.d.ts

@@ -1,9 +1,189 @@
 import type * as BABYLON from "@babylonjs/core/Legacy/legacy";
 declare const BABYLON: any;
-import { ScriptComponent, AudioSource, RigidbodyPhysics, AnimationState, ShurikenParticles, IUnityVector3, IUnityVector4, RaycastVehicle, btWheelInfo, PlayerNumber, CustomShaderMaterial, CustomShaderMaterialPlugin, PreloadAssetsManager, IAssetPreloader, CharacterController } 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;
@@ -31,7 +211,17 @@ export declare class KartLapCounter extends ScriptComponent {
     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;
@@ -39,8 +229,13 @@ export declare class KartLapCounter extends ScriptComponent {
     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;
@@ -62,6 +257,14 @@ export declare class KartOutOfBounds extends ScriptComponent {
     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,
@@ -75,7 +278,23 @@ export interface IKartCountdownBeat {
 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;
@@ -86,21 +305,252 @@ export declare class KartRaceManager extends ScriptComponent {
     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;
 }
@@ -121,6 +571,7 @@ export declare class KartAntiGravityExitVolume extends KartVolume {
 export declare class KartGliderVolume extends KartVolume {
     glideAngle: number;
     glideAngleX: number;
+    angleOnly: boolean;
     protected awake(): void;
 }
 export declare class KartGliderPanel extends KartVolume {
@@ -155,6 +606,80 @@ 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;
@@ -186,6 +711,22 @@ export interface IKartVoiceRota {
 }
 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;
@@ -238,17 +779,57 @@ export declare class KartClipVoice implements IKartAudioVoice {
     private playing;
     private playCount;
     private lastDelay;
-    constructor(source: any, duration?: number);
+    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;
@@ -270,8 +851,22 @@ export declare class KartManagedVoice implements IKartAudioVoice {
     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;
@@ -288,12 +883,21 @@ export interface IKartAudioTarget {
     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;
@@ -343,7 +947,9 @@ export declare class StandardKartAudio extends ScriptComponent {
     protected mutedVoices: Set<string>;
     protected mutedGroups: Set<string>;
     voiceSourceNames: any;
-    voiceClips: any;
+    voiceClips: Record<string, IKartClipDescriptor>;
+    preferVoiceClips: string[];
+    voiceSlotsMuted: string[];
     voiceSoundNames: any;
     voiceTunings: any;
     voiceVolumes: any;
@@ -353,9 +959,13 @@ export declare class StandardKartAudio extends ScriptComponent {
     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;
@@ -365,9 +975,15 @@ export declare class StandardKartAudio extends ScriptComponent {
     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;
@@ -376,13 +992,24 @@ export declare class StandardKartAudio extends ScriptComponent {
     static SlotDuration(slot: IKartVoiceSlot): number;
     protected tuneSlot(slot: IKartVoiceSlot): IKartVoiceSlot;
     protected resolveSlot(slot: IKartVoiceSlot): IKartAudioVoice;
-    protected buildClipSource(slot: IKartVoiceSlot, clip: any): 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;
@@ -390,12 +1017,33 @@ export declare class StandardKartAudio extends ScriptComponent {
     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;
@@ -405,6 +1053,8 @@ export declare class StandardKartAudio extends ScriptComponent {
     getSoundCount(): number;
     getEngineTime(): number;
     getEnginePitch(): number;
+    getIdleLevel(): number;
+    setSceneEntryFinished(finished: boolean): void;
     getHopVoice(): IKartAudioVoice;
     getLandSkidVoice(): IKartAudioVoice;
     getChassisVoice(): IKartAudioVoice;
@@ -430,6 +1080,9 @@ export declare class StandardKartAudio extends ScriptComponent {
     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;
@@ -479,6 +1132,8 @@ export declare class StandardKartCamera extends ScriptComponent {
     heightOffset: number;
     orig_pos: BABYLON.Vector3;
     boost_pos: BABYLON.Vector3;
+    cameraLocalPosition: BABYLON.Vector3;
+    cameraLocalRotation: BABYLON.Quaternion;
     defaultChildPitch: number;
     antiGravityPosY: number;
     antiGravityTailSeconds: number;
@@ -493,6 +1148,12 @@ export declare class StandardKartCamera extends ScriptComponent {
     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;
@@ -531,8 +1192,11 @@ export declare function approachRate(current: number, target: number, ratePerSec
 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;
@@ -544,14 +1208,32 @@ 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;
@@ -562,6 +1244,8 @@ 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;
@@ -576,6 +1260,11 @@ 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;
@@ -598,10 +1287,39 @@ 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;
@@ -627,7 +1345,30 @@ export declare enum EKartBoostSource {
     JumpPanel = 4,
     GliderExit = 5,
     GliderTrick = 6,
-    DriftPayout = 7
+    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,
@@ -641,6 +1382,12 @@ export interface IKartVehicleProfile {
     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 {
@@ -649,16 +1396,33 @@ export declare class StandardKartController extends ScriptComponent {
     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;
@@ -669,13 +1433,19 @@ export declare class StandardKartController extends ScriptComponent {
     vehicleProfile: KartVehicleProfileName | null;
     hopEnabled: boolean;
     gliderEnabled: boolean;
-    enableGliderPhysics: 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;
@@ -712,6 +1482,7 @@ export declare class StandardKartController extends ScriptComponent {
     protected exitRotateY: boolean;
     protected exitRotateZ: boolean;
     protected exitRotateTarget: BABYLON.Vector3;
+    private exitRotateVolume;
     private exitEuler;
     private exitQuaternion;
     private jumpRotation;
@@ -721,6 +1492,7 @@ export declare class StandardKartController extends ScriptComponent {
     protected yawRate: number;
     protected slipAngle: number;
     protected inputThrottle: number;
+    protected inputBraking: boolean;
     protected inputSteering: number;
     protected inputDrifting: boolean;
     protected inputTrick: boolean;
@@ -757,10 +1529,8 @@ export declare class StandardKartController extends ScriptComponent {
     protected gliderLanded: boolean;
     protected max_speed: number;
     protected Boost: boolean;
-    protected StarPowerUp: boolean;
     protected cancelAddforceDown: boolean;
-    protected airForceVolume: BABYLON.TransformNode;
-    private airForceDirection;
+    protected airForceVolumes: BABYLON.TransformNode[];
     protected wheelNodes: BABYLON.TransformNode[];
     protected wheelRestPositions: BABYLON.Vector3[];
     protected wheelRestRotations: BABYLON.Quaternion[];
@@ -773,16 +1543,20 @@ export declare class StandardKartController extends ScriptComponent {
     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 spunOut: boolean;
     protected onDirt: boolean;
     protected awake(): void;
     protected start(): void;
     protected update(): void;
+    protected late(): void;
     protected step(): void;
     protected fixed(): void;
     protected destroy(): void;
@@ -795,8 +1569,10 @@ export declare class StandardKartController extends ScriptComponent {
     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;
@@ -818,11 +1594,16 @@ export declare class StandardKartController extends ScriptComponent {
     protected tickTrick(dt: number): void;
     protected landTrick(): void;
     protected enterGliderSection(volume: BABYLON.TransformNode): void;
-    protected openGlider(): 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;
@@ -830,18 +1611,34 @@ export declare class StandardKartController extends ScriptComponent {
     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;
@@ -865,6 +1662,7 @@ export declare class StandardKartController extends ScriptComponent {
     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;
@@ -883,20 +1681,46 @@ export declare class StandardKartController extends ScriptComponent {
     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;
-    protected animator: any;
-    protected animatorOwnsDriftPose(): boolean;
+    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;
@@ -905,18 +1729,47 @@ export declare class StandardKartController extends ScriptComponent {
     protected idleTime: number;
     protected underwaterBlend: number;
     protected underwaterHand: number;
-    protected wasAtRest: boolean;
+    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;
@@ -926,6 +1779,41 @@ export declare class StandardKartController extends ScriptComponent {
     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;
@@ -940,20 +1828,133 @@ export declare class StandardKartController extends ScriptComponent {
     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): 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[];
@@ -1012,8 +2013,10 @@ export declare class StandardKartController extends ScriptComponent {
     getLastBoostSource(): EKartBoostSource;
     isFellInWater(): boolean;
     isRaceCompleted(): boolean;
+    isRaceStarted(): boolean;
 }
 export interface IKartEffectsTarget {
+    transform?: BABYLON.TransformNode;
     getDriftState(): number;
     getDriftTime(): number;
     getDriftTierTimes?(): number[];
@@ -1029,7 +2032,20 @@ export interface IKartEffectsTarget {
     sparkTier1Color?: string;
     sparkTier2Color?: string;
     sparkTier3Color?: string;
-    isFellInWater?(): boolean;
+    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;
@@ -1040,15 +2056,26 @@ export interface IKartEmitterGroup {
     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;
@@ -1062,6 +2089,10 @@ export declare class StandardKartEffects extends ScriptComponent {
     antiGravSpinNodeName: string;
     trickParticlesNodeName: string;
     groundLandNodeName: string;
+    dustNodeName: string;
+    starNodeName: string;
+    exhaustNodeName: string;
+    startDustNodeName: string;
     sparkTier1Color: string;
     sparkTier2Color: string;
     sparkTier3Color: string;
@@ -1084,12 +2115,20 @@ export declare class StandardKartEffects extends ScriptComponent {
     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;
@@ -1097,8 +2136,13 @@ export declare class StandardKartEffects extends ScriptComponent {
     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): 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;
@@ -1226,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;
@@ -1505,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;
@@ -1679,7 +2609,6 @@ export declare class StandardCarController extends ScriptComponent {
     powerBooster: boolean;
     linkTrackManager: boolean;
     playVehicleSounds: boolean;
-    postNetworkAttributes: boolean;
     wheelDriveType: number;
     gearBoxMultiplier: number;
     currentPitchScale: number;
@@ -2142,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;
@@ -2314,53 +3226,6 @@ export declare class AssetPreloader extends ScriptComponent implements IAssetPre
     protected destroy(): void;
     addPreloaderTasks(assetsManager: PreloadAssetsManager): void;
 }
-export declare class NodeMaterialInstance extends ScriptComponent {
-    private nodeMaterialData;
-    private setCustomRootUrl;
-    getMaterialInstance(): BABYLON.NodeMaterial;
-    protected m_nodeMaterial: BABYLON.NodeMaterial;
-    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
-    protected awake(): void;
-    protected destroy(): void;
-}
-export declare class NodeMaterialParticle extends ScriptComponent {
-    private nodeMaterialEditor;
-    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
-    protected awake(): void;
-    protected start(): void;
-    protected setupNodeMaterial(materialInstance: BABYLON.NodeMaterial): void;
-    protected update(): void;
-    protected late(): void;
-    protected after(): void;
-    protected fixed(): void;
-    protected ready(): void;
-    protected destroy(): void;
-}
-export declare class NodeMaterialProcess extends ScriptComponent {
-    private nodeMaterialEditor;
-    private numberOfSamples;
-    private samplingMode;
-    private textureType;
-    private textureFormat;
-    private sizeRatio;
-    private resuable;
-    getPostProcess(): BABYLON.PostProcess;
-    protected m_postProcess: BABYLON.PostProcess;
-    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
-    protected start(): void;
-    protected setupNodeMaterial(materialInstance: BABYLON.NodeMaterial): void;
-    protected destroy(): void;
-}
-export declare class NodeMaterialTexture extends ScriptComponent {
-    private nodeMaterialEditor;
-    private textureSize;
-    getProceduralTexture(): BABYLON.ProceduralTexture;
-    protected m_proceduralTexture: BABYLON.ProceduralTexture;
-    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
-    protected start(): void;
-    protected setupNodeMaterial(materialInstance: BABYLON.NodeMaterial): void;
-    protected destroy(): void;
-}
 export declare class MobileInputController extends ScriptComponent {
     static get Instance(): MobileInputController;
     private static StaticInstance;
@@ -2441,98 +3306,11 @@ export declare class MobileShadowMaterial extends ScriptComponent {
     protected awake(): void;
     protected destroy(): void;
 }
-export declare class BallSocketJoint extends ScriptComponent {
-    bodyA: BABYLON.TransformNode;
-    bodyB: BABYLON.TransformNode;
-    pivotA: BABYLON.Vector3;
-    pivotB: BABYLON.Vector3;
-    axisA: BABYLON.Vector3;
-    axisB: BABYLON.Vector3;
-    constraint: BABYLON.BallAndSocketConstraint;
-    collisionsEnabled: boolean;
-    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
-    protected awake(): void;
-    protected destroy(): void;
-}
-export declare class DistanceJoint extends ScriptComponent {
-    bodyA: BABYLON.TransformNode;
-    bodyB: BABYLON.TransformNode;
-    maxDistance: number;
-    constraint: BABYLON.DistanceConstraint;
-    collisionsEnabled: boolean;
-    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
-    protected awake(): void;
-    protected destroy(): void;
-}
-export declare class FixedHingeJoint extends ScriptComponent {
-    bodyA: BABYLON.TransformNode;
-    bodyB: BABYLON.TransformNode;
-    pivotA: BABYLON.Vector3;
-    pivotB: BABYLON.Vector3;
-    constraint: BABYLON.HingeConstraint;
-    collisionsEnabled: boolean;
-    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
-    protected awake(): void;
-    protected destroy(): void;
-}
-export declare class LockedJoint extends ScriptComponent {
-    bodyA: BABYLON.TransformNode;
-    bodyB: BABYLON.TransformNode;
-    pivotA: BABYLON.Vector3;
-    pivotB: BABYLON.Vector3;
-    axisA: BABYLON.Vector3;
-    axisB: BABYLON.Vector3;
-    constraint: BABYLON.LockConstraint;
-    collisionsEnabled: boolean;
-    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
-    protected awake(): void;
-    protected destroy(): void;
-}
-export declare class PrismaticJoint extends ScriptComponent {
-    bodyA: BABYLON.TransformNode;
-    bodyB: BABYLON.TransformNode;
-    pivotA: BABYLON.Vector3;
-    pivotB: BABYLON.Vector3;
-    axisA: BABYLON.Vector3;
-    axisB: BABYLON.Vector3;
-    constraint: BABYLON.PrismaticConstraint;
-    collisionsEnabled: boolean;
-    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
-    protected awake(): void;
-    protected destroy(): void;
-}
-export declare class SixdofJoint extends ScriptComponent {
-    bodyA: BABYLON.TransformNode;
-    bodyB: BABYLON.TransformNode;
-    pivotA: BABYLON.Vector3;
-    pivotB: BABYLON.Vector3;
-    perpAxisA: BABYLON.Vector3;
-    perpAxisB: BABYLON.Vector3;
-    axisLimits: BABYLON.Physics6DoFLimit[];
-    constraint: BABYLON.Physics6DoFConstraint;
-    collisionsEnabled: boolean;
-    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
-    protected awake(): void;
-    protected destroy(): void;
-}
-export declare class SliderJoint extends ScriptComponent {
-    bodyA: BABYLON.TransformNode;
-    bodyB: BABYLON.TransformNode;
-    pivotA: BABYLON.Vector3;
-    pivotB: BABYLON.Vector3;
-    axisA: BABYLON.Vector3;
-    axisB: BABYLON.Vector3;
-    constraint: BABYLON.SliderConstraint;
-    collisionsEnabled: boolean;
-    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
-    protected awake(): void;
-    protected destroy(): void;
-}
 export declare class RemotePlayerController extends ScriptComponent {
     updateStateParams: boolean;
     smoothMotionTime: number;
     smoothInputVectors: boolean;
-    private animationState;
+    private animator;
     private animationStateParams;
     constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
     protected awake(): void;
@@ -2591,6 +3369,7 @@ export declare class StandardPlayerController extends ScriptComponent {
     cameraSmoothing: number;
     cameraCollisions: boolean;
     inputMagnitude: number;
+    analogMovement: boolean;
     landingEpsilon: number;
     minimumDistance: number;
     movementAllowed: boolean;
@@ -2623,7 +3402,7 @@ export declare class StandardPlayerController extends ScriptComponent {
     getMovementSpeed(): number;
     getCameraBoomNode(): BABYLON.TransformNode;
     getCameraTransform(): BABYLON.TransformNode;
-    getAnimationState(): AnimationState;
+    getAnimator(): Animator;
     getVerticalVelocity(): number;
     getCharacterController(): CharacterController;
     getPlayerLookRotation(): BABYLON.Vector3;
@@ -2706,7 +3485,7 @@ export declare class StandardPlayerController extends ScriptComponent {
     private delayJumpTimer;
     private playerControl;
     private canPlayerJump;
-    private animationState;
+    private animator;
     private lastJumpVelocity;
     private inputMovementVector;
     private playerLookRotation;
@@ -2755,10 +3534,11 @@ export declare class StandardPlayerController extends ScriptComponent {
     onPlayerInputObservable: any;
     onPlayerPositionObservable: any;
     onUpdateActionObservable: any;
-    private _deltaMotionPosition;
-    getDeltaMotionPosition(): BABYLON.Vector3;
-    private _deltaMotionRotation;
-    getDeltaMotionRotation(): BABYLON.Quaternion;
+    private animatorMoveObserver;
+    private exportedApplyRootMotion;
+    private readonly rootMotionVelocity;
+    private syncAnimatorMoveTaker;
+    private onAnimatorMove;
     private isPerformingAction;
     private isRootMotionAction;
     private isActionInterruptable;
@@ -2778,12 +3558,19 @@ export declare class StandardPlayerController extends ScriptComponent {
     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;
@@ -2820,6 +3607,9 @@ export declare class StandardPlayerController extends ScriptComponent {
     isGroundedFootIKActive(): boolean;
     setupBoneControllers(): void;
     private attachAnimationController;
+    private onAnimatorStateEnter;
+    private onAnimatorStateExit;
+    private onAnimatorIKPass;
     private updateAnimatorTargetMeshes;
     enableCharacterController(state: boolean): void;
     resetPlayerRotation(): void;
@@ -2842,6 +3632,7 @@ export declare class StandardPlayerController extends ScriptComponent {
     private getCheckedVerticalVelocity;
     private destroyPlayerController;
     private validateAnimationStateParams;
+    static ApplyAnimationStateParamDefaults(params: AnimationStateParams): AnimationStateParams;
 }
 export interface AnimationStateParams {
     moveDirection: string;
@@ -2852,6 +3643,7 @@ export interface AnimationStateParams {
     mouseYInput: string;
     heightInput: string;
     speedInput: string;
+    motionSpeed?: string;
     jumpFrame: string;
     jumpState: string;
     actionState: string;
@@ -2918,6 +3710,7 @@ export declare class ThirdPersonPlayerController extends ScriptComponent {
     useClimbSystem: boolean;
     distanceFactor: number;
     inputMagnitude: number;
+    analogMovement: boolean;
     landingEpsilon: number;
     minimumDistance: number;
     movementAllowed: boolean;
@@ -2946,7 +3739,7 @@ export declare class ThirdPersonPlayerController extends ScriptComponent {
     getPlayerGrounded(): boolean;
     getFallTriggered(): boolean;
     getMovementSpeed(): number;
-    getAnimationState(): AnimationState;
+    getAnimator(): Animator;
     getVerticalVelocity(): number;
     getCharacterController(): CharacterController;
     getPlayerLookRotation(): BABYLON.Vector3;
@@ -3006,7 +3799,7 @@ export declare class ThirdPersonPlayerController extends ScriptComponent {
     private deltaTime;
     private delayJumpTimer;
     private canPlayerJump;
-    private animationState;
+    private animator;
     private lastJumpVelocity;
     private inputMovementVector;
     private playerLookRotation;
@@ -3056,10 +3849,11 @@ export declare class ThirdPersonPlayerController extends ScriptComponent {
     onPlayerPositionObservable: any;
     onUpdateActionObservable: any;
     onAnimationStateObservable: any;
-    private _deltaMotionPosition;
-    getDeltaMotionPosition(): BABYLON.Vector3;
-    private _deltaMotionRotation;
-    getDeltaMotionRotation(): BABYLON.Quaternion;
+    private animatorMoveObserver;
+    private exportedApplyRootMotion;
+    private readonly rootMotionVelocity;
+    private syncAnimatorMoveTaker;
+    private onAnimatorMove;
     private isPerformingAction;
     private isRootMotionAction;
     private isActionInterruptable;
@@ -3079,12 +3873,19 @@ export declare class ThirdPersonPlayerController extends ScriptComponent {
     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;
@@ -3117,6 +3918,9 @@ export declare class ThirdPersonPlayerController extends ScriptComponent {
     isGroundedFootIKActive(): boolean;
     setupBoneControllers(): void;
     private attachAnimationController;
+    private onAnimatorStateEnter;
+    private onAnimatorStateExit;
+    private onAnimatorIKPass;
     private updateAnimatorTargetMeshes;
     enableCharacterController(state: boolean): void;
     resetPlayerJumpingState(): void;
@@ -3131,78 +3935,12 @@ export declare class ThirdPersonPlayerController extends ScriptComponent {
     private getCheckedVerticalVelocity;
     private destroyPlayerController;
     private validateAnimationStateParams;
+    static ApplyAnimationStateParamDefaults(params: AnimationStateParams): AnimationStateParams;
 }
 export declare enum ThirdPersonControl {
     ThirdPersonTurning = 0,
     ThirdPersonForward = 1
 }
-export declare class FxParticleSystem extends ScriptComponent {
-    getParticleEmitter(): BABYLON.AbstractMesh;
-    getParticleSystem(): BABYLON.ParticleSystem | BABYLON.GPUParticleSystem;
-    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
-    protected m_particleEmitter: BABYLON.AbstractMesh;
-    protected m_particleSystem: BABYLON.ParticleSystem | BABYLON.GPUParticleSystem;
-    protected awake(): void;
-    protected destroy(): void;
-}
-export declare class SkyMaterialSystem extends ScriptComponent {
-    private skyfog;
-    private skysize;
-    private probesize;
-    private reflections;
-    private reflectlevel;
-    private skytintcolor;
-    getSkyboxMesh(): BABYLON.AbstractMesh;
-    getSkyMaterial(): BABYLON.SkyMaterial;
-    getReflectionProbe(): BABYLON.ReflectionProbe;
-    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
-    protected awake(): void;
-    protected start(): void;
-    protected update(): void;
-    protected late(): void;
-    protected after(): void;
-    protected destroy(): void;
-    protected m_skyboxMesh: BABYLON.Mesh;
-    protected m_skyMaterial: BABYLON.SkyMaterial;
-    protected m_reflectProbe: BABYLON.ReflectionProbe;
-    protected awakeSkyboxMaterial(): void;
-    protected destroySkyboxMaterial(): void;
-    setSkyboxTintColor(color: BABYLON.Color3): void;
-}
-export declare class WaterMaterialSystem extends ScriptComponent {
-    private waterTag;
-    private targetSize;
-    private renderSize;
-    private depthFactor;
-    private reflectSkybox;
-    private subDivisions;
-    private heightOffset;
-    private windDirection;
-    private windForce;
-    private waveSpeed;
-    private waveLength;
-    private waveHeight;
-    private bumpHeight;
-    private bumpSuperimpose;
-    private bumpAffectsReflection;
-    private waterColor;
-    private colorBlendFactor;
-    private waterColor2;
-    private colorBlendFactor2;
-    private disableClipPlane;
-    private fresnelSeparate;
-    getWaterGeometry(): BABYLON.AbstractMesh;
-    getWaterMaterial(): BABYLON.WaterMaterial;
-    protected m_waterGeometry: BABYLON.AbstractMesh;
-    protected m_waterMaterial: BABYLON.WaterMaterial;
-    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
-    protected awake(): void;
-    protected start(): void;
-    protected update(): void;
-    protected late(): void;
-    protected after(): void;
-    protected destroy(): void;
-}
 export declare class SnapshotManager extends ScriptComponent {
     static IsSnapshotRenderingEnabled(): boolean;
     static EnableSnapshotRendering(): void;
@@ -3281,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>;