babylonjs-addons 8.29.0 → 8.29.2

package/babylonjs.addons.module.d.ts

@@ -3,272 +3,1700 @@ declare module "babylonjs-addons/index" {
 export * from "babylonjs-addons/atmosphere/index";
 export * from "babylonjs-addons/htmlMesh/index";
 export * from "babylonjs-addons/msdfText/index";
+export * from "babylonjs-addons/navigation/index";
 
 }
-declare module "babylonjs-addons/msdfText/textRenderer" {
-import { AbstractEngine } from "babylonjs/Engines/abstractEngine";
-import { IDisposable } from "babylonjs/scene";
+declare module "babylonjs-addons/navigation/types" {
+
+
+import { IVector3Like } from "babylonjs/Maths/math.like";
+import { Vector3 } from "babylonjs/Maths/math.vector";
+import { IAgentParameters, INavMeshParameters } from "babylonjs/Navigation/INavigationEngine";
 import { Nullable } from "babylonjs/types";
-import { FontAsset } from "babylonjs-addons/msdfText/fontAsset";
-import { ParagraphOptions } from "babylonjs-addons/msdfText/paragraphOptions";
-import { IColor4Like, IMatrixLike } from "babylonjs/Maths/math.like";
 /**
- * Abstract Node class from Babylon.js
+ * Recast injection type
  */
-export interface INodeLike {
-    getWorldMatrix(): IMatrixLike;
-}
+export type RecastInjection = any;
 /**
- * Class used to render text using MSDF (Multi-channel Signed Distance Field) technique
- * Thanks a lot to the work of Bhushan_Wagh and zb_sj for their amazing work on MSDF for Babylon.js
- * #6RLCWP#16
- * Star wars scroller: #6RLCWP#29
- * With metrics: #6RLCWP#35
- * Thickness: #IABMEZ#3
- * Solar system: #9YCDYC#9
- * Stroke: #6RLCWP#37
+ * Off-mesh connection data
  */
-export class TextRenderer implements IDisposable {
-    private readonly _useVAO;
-    private _engine;
-    private _shaderLanguage;
-    private _vertexBuffers;
-    private _spriteBuffer;
-    private _worldBuffer;
-    private _uvBuffer;
-    private _drawWrapperBase;
-    private _vertexArrayObject;
-    private _font;
-    private _charMatrices;
-    private _charUvs;
-    private _isDirty;
-    private _baseLine;
-    private _scalingMatrix;
-    private _fontScaleMatrix;
-    private _offsetMatrix;
-    private _translationMatrix;
-    private _baseMatrix;
-    private _scaledMatrix;
-    private _localMatrix;
-    private _finalMatrix;
-    private _lineMatrix;
-    private _parentWorldMatrix;
+export interface IOffMeshConnection {
     /**
-     * Gets or sets the color of the text
+     * The start position of the off-mesh connection.
      */
-    color: IColor4Like;
+    startPosition: IVector3Like;
     /**
-     * Gets or sets the color of the stroke around the text
+     * The end position of the off-mesh connection.
      */
-    strokeColor: IColor4Like;
+    endPosition: IVector3Like;
     /**
-     * Gets or sets the width of the stroke around the text (inset)
+     * The radius of the off-mesh connection.
      */
-    strokeInsetWidth: number;
+    radius: number;
     /**
-     * Gets or sets the width of the stroke around the text (outset)
+     * The type of the off-mesh connection.
      */
-    strokeOutsetWidth: number;
+    bidirectional: boolean;
     /**
-     * Gets or sets the thickness of the text (0 means as defined in the font)
-     * Value must be between -0.5 and 0.5
+     * The area type of the off-mesh connection.
      */
-    thicknessControl: number;
-    private _parent;
+    area: number;
     /**
-     * Gets or sets the parent of the text renderer
+     * The flags of the off-mesh connection.
      */
-    get parent(): Nullable<INodeLike>;
-    set parent(value: Nullable<INodeLike>);
-    private _transformMatrix;
+    flags: number;
     /**
-     * Gets or sets the transform matrix of the text renderer
-     * It will be applied in that order:
-     * parent x transform x paragraph world
+     * The user ID of the off-mesh connection.
+     * @remarks This can be used to associate the off-mesh connection with a specific user
      */
-    get transformMatrix(): IMatrixLike;
-    set transformMatrix(value: IMatrixLike);
+    userId?: number;
+}
+/**
+ * Result of a navigation mesh creation.
+ */
+export type CreateNavMeshResult = Nullable<{
     /**
-     * Gets or sets if the text is billboarded
+     * Navigation mesh
      */
-    isBillboard: boolean;
+    navMesh: any;
     /**
-     * Gets or sets if the text is screen projected
-     * This will work only if the text is billboarded
+     * Navigation mesh query
      */
-    isBillboardScreenProjected: boolean;
+    navMeshQuery: any;
     /**
-     * Gets the number of characters in the text renderer
+     * Intermediates generated during the any creation process.
+     * @remarks This is only available if the `keepIntermediates` parameter is set to true in the `INavMeshParametersV2`.
+     * It can be used for debugging or visualization purposes.
      */
-    get characterCount(): number;
+    intermediates?: GeneratorIntermediates;
     /**
-     * Gets or sets if the text renderer should ignore the depth buffer
-     * Default is false
+     * Tile cache generated during the any creation process.
+     * @remarks This is only available if the `maxObstacles` parameter is set to a value greater than 0 in the `INavMeshParametersV2`. Defaults `maxObstacles` to 128.
+     * It can be used for obstacle avoidance and dynamic navigation mesh updates.
+     * @see {@link INavMeshParametersV2}
      */
-    ignoreDepthBuffer: boolean;
-    private constructor();
-    private _resizeBuffers;
-    private _setShaders;
+    tileCache?: any;
+}>;
+/**
+ * Agent parameters
+ * For actual limits and default values check the recast-navigation-js docs.
+ * @see https://docs.recast-navigation-js.isaacmason.com/types/index.CrowdAgentParams.html
+ */
+export interface IAgentParametersV2 extends IAgentParameters {
     /**
-     * Add a paragraph of text to the renderer
-     * @param text define the text to add
-     * @param options define the options to use for the paragraph (optional)
-     * @param worldMatrix define the world matrix to use for the paragraph (optional)
+     * Flags that impact steering behavior.
      */
-    addParagraph(text: string, options?: Partial<ParagraphOptions>, worldMatrix?: IMatrixLike): void;
+    updateFlags: number;
     /**
-     * Render the text using the provided view and projection matrices
-     * @param viewMatrix define the view matrix to use
-     * @param projectionMatrix define the projection matrix to use
+     * The index of the avoidance configuration to use for the agent. [Limits: 0 to #DT_CROWD_MAX_OBSTAVOIDANCE_PARAMS inclusive]
      */
-    render(viewMatrix: IMatrixLike, projectionMatrix: IMatrixLike): void;
+    obstacleAvoidanceType: number;
     /**
-     * Release associated resources
+     * The index of the query filter used by this agent.
      */
-    dispose(): void;
+    queryFilterType: number;
     /**
-     * Creates a new TextRenderer instance asynchronously
-     * @param font define the font asset to use
-     * @param engine define the engine to use
-     * @returns a promise that resolves to the created TextRenderer instance
+     * User defined data attached to the agent.
      */
-    static CreateTextRendererAsync(font: FontAsset, engine: AbstractEngine): Promise<TextRenderer>;
+    userData: unknown;
 }
-
+/**
+ * any parameters
+ * For actual limits and default values check the recast-navigation-js docs.
+ * @see https://docs.recast-navigation-js.isaacmason.com/types/index.RecastConfig.html
+ */
+export interface INavMeshParametersV2 extends INavMeshParameters {
+    /**
+     * OffMeshConnections - Teleports
+     */
+    offMeshConnections?: IOffMeshConnection[];
+    /**
+     * Whether to keep intermediate navigation mesh data for debug visualization. Default is false.
+     */
+    keepIntermediates?: boolean;
+    /**
+     * The maximum number of obstacles that can be added to the navigation mesh. Default is 32.
+     * If this value is greater then 0, the navigation mesh will be generated with a tile cache.
+     */
+    maxObstacles?: number;
+    /**
+     * The size of each tile in the tiled navigation mesh. Default is 32.
+     */
+    expectedLayersPerTile?: number;
+    /**
+     * Function which is sets the polyAreas and polyFlags for the tile cache mesh. Defaults to a function that sets all areas to 0 and flags to 1.
+     */
+    tileCacheMeshProcess?: any;
 }
-declare module "babylonjs-addons/msdfText/paragraphOptions" {
-import { IVector2Like } from "babylonjs/Maths/math.like";
-/** @internal */
-export type ParagraphOptions = {
-    maxWidth: number;
-    lineHeight: number;
-    letterSpacing: number;
-    tabSize: number;
-    whiteSpace: "pre-line";
-    textAlign: "left" | "right" | "center";
-    translate: IVector2Like | undefined;
+/**
+ * Result of a steer target computation.
+ */
+export type SteerTargetResult = {
+    /**
+     * Indicates whether the steering target computation was successful.
+     */
+    success: false;
+} | {
+    /**
+     * Indicates whether the steering target computation was successful.
+     */
+    success: true;
+    /**
+     * The position to steer towards.
+     */
+    steerPos: Vector3;
+    /**
+     * The flag indicating the type of steering position.
+     */
+    steerPosFlag: number;
+    /**
+     * The reference to the polygon that the steering position is associated with.
+     */
+    steerPosRef: number;
+    /**
+     * The points that make up the path to the steering position.
+     */
+    points: Vector3[];
 };
-/** @internal */
-export const DefaultParagraphOptions: ParagraphOptions;
-
-}
-declare module "babylonjs-addons/msdfText/index" {
-export * from "babylonjs-addons/msdfText/fontAsset";
-export * from "babylonjs-addons/msdfText/paragraphOptions";
-export * from "babylonjs-addons/msdfText/textRenderer";
-export * from "babylonjs-addons/msdfText/sdf/index";
-export * from "babylonjs-addons/msdfText/shaders/msdf.vertex";
-export * from "babylonjs-addons/msdfText/shaders/msdf.fragment";
-export * from "babylonjs-addons/msdfText/shadersWGSL/msdf.vertex";
-export * from "babylonjs-addons/msdfText/shadersWGSL/msdf.fragment";
-
-}
-declare module "babylonjs-addons/msdfText/fontAsset" {
-import { IDisposable, Scene } from "babylonjs/scene";
-import { BMFontChar } from "babylonjs-addons/msdfText/sdf/bmFont";
-import { SdfFont } from "babylonjs-addons/msdfText/sdf/font";
-import { Texture } from "babylonjs/Materials/Textures/texture";
 /**
- * Class representing a font asset for SDF (Signed Distance Field) rendering.
+ * Error types for path computation.
  */
-export class FontAsset implements IDisposable {
-    private readonly _chars;
-    private readonly _charsRegex;
-    private readonly _kernings;
-    /** @internal */
-    readonly _font: SdfFont;
+export const ComputePathError: {
+    START_NEAREST_POLY_FAILED: string;
+    END_NEAREST_POLY_FAILED: string;
+    FIND_PATH_FAILED: string;
+    NO_POLYGON_PATH_FOUND: string;
+    NO_CLOSEST_POINT_ON_LAST_POLYGON_FOUND: string;
+};
+export type ComputePathErrorType = (typeof ComputePathError)[keyof typeof ComputePathError];
+/**
+ * Result of a path computation.
+ */
+export type ComputePathResult = {
     /**
-     * Gets the font scale value
+     * Indicates whether the path computation was successful.
      */
-    readonly scale: number;
+    success: boolean;
     /**
-     * Gets the list of used textures
+     * The error message if the path computation failed.
      */
-    readonly textures: Texture[];
+    error?: {
+        /**
+         * A descriptive error message.
+         */
+        name?: string;
+        /**
+         * The type of error that occurred during path computation.
+         * @remarks This will be one of the values from `ComputePathError`
+         */
+        type?: ComputePathErrorType;
+        /**
+         * Statusring describing the error.
+         */
+        status?: number;
+    };
     /**
-     * Creates a new FontAsset instance.
-     * @param definitionData defines the font data in JSON format.
-     * @param textureUrl defines the url of the texture to use for the font.
-     * @param scene defines the hosting scene.
+     * The computed path as an array of Vector3 points.
      */
-    constructor(definitionData: string, textureUrl: string, scene?: Scene);
-    dispose(): void;
-    private _updateFallbacks;
-    /** @internal */
-    _getChar(charCode: number): BMFontChar;
-    /** @internal */
-    _getKerning(first: number, second: number): number;
-    /** @internal */
-    _unsupportedChars(text: string): string;
-}
-
-}
-declare module "babylonjs-addons/msdfText/shadersWGSL/msdf.vertex" {
-/** @internal */
-export const msdfVertexShaderWGSL: {
-    name: string;
-    shader: string;
+    path: IVector3Like[];
 };
+/**
+ * Intermediates generated during the any creation process.
+ * @remarks This is only available if the `keepIntermediates` parameter is set to true in the `INavMeshParametersV2`.
+ * It can be used for debugging or visualization purposes.
+ */
+export type GeneratorIntermediates = any | any | any | null;
 
 }
-declare module "babylonjs-addons/msdfText/shadersWGSL/msdf.fragment" {
-/** @internal */
-export const msdfPixelShaderWGSL: {
-    name: string;
-    shader: string;
-};
+declare module "babylonjs-addons/navigation/index" {
+export * from "babylonjs-addons/navigation/plugin/index";
+export * from "babylonjs-addons/navigation/factory/index";
+export * from "babylonjs-addons/navigation/common/index";
+export * from "babylonjs-addons/navigation/generator/index";
+export * from "babylonjs-addons/navigation/debug/index";
 
 }
-declare module "babylonjs-addons/msdfText/shaders/msdf.vertex" {
-/** @internal */
-export const msdfVertexShader: {
-    name: string;
-    shader: string;
-};
+declare module "babylonjs-addons/navigation/worker/navmesh-worker" {
+/**
+ * Generates a navigation mesh in a web worker.
+ */
+export function GenerateNavMeshWorker(): void;
 
 }
-declare module "babylonjs-addons/msdfText/shaders/msdf.fragment" {
-/** @internal */
-export const msdfPixelShader: {
-    name: string;
-    shader: string;
-};
+declare module "babylonjs-addons/navigation/plugin/index" {
+export * from "babylonjs-addons/navigation/plugin/RecastNavigationJSPlugin";
 
 }
-declare module "babylonjs-addons/msdfText/sdf/paragraph" {
-import { FontAsset } from "babylonjs-addons/msdfText/fontAsset";
-import { type ParagraphOptions } from "babylonjs-addons/msdfText/paragraphOptions";
-import { SdfGlyph } from "babylonjs-addons/msdfText/sdf/glyph";
-import { SdfTextLine } from "babylonjs-addons/msdfText/sdf/line";
-/** @internal */
-export class SdfTextParagraph {
-    readonly text: string;
-    readonly fontAsset: FontAsset;
-    readonly options: ParagraphOptions;
-    get lineHeight(): number;
-    readonly paragraph: string;
-    readonly lines: SdfTextLine[];
-    readonly width: number;
-    readonly height: number;
-    readonly glyphs: SdfGlyph[];
-    constructor(text: string, fontAsset: FontAsset, options?: Partial<ParagraphOptions>);
-    private _computeMetrics;
-    private _breakLines;
-    private _collapse;
-    private _wrap;
-}
+declare module "babylonjs-addons/navigation/plugin/RecastNavigationJSPlugin" {
 
-}
-declare module "babylonjs-addons/msdfText/sdf/line" {
-import { SdfGlyph } from "babylonjs-addons/msdfText/sdf/glyph";
-/** @internal */
-export type SdfTextLine = {
-    text: string;
-    glyphs: SdfGlyph[];
-    start: number;
-    end: number;
-    width: number;
-};
+import { ICrowd, INavigationEnginePlugin, IObstacle } from "babylonjs/Navigation/INavigationEngine";
+import { Mesh } from "babylonjs/Meshes/mesh";
+import { Scene } from "babylonjs/scene";
+import { Vector3 } from "babylonjs/Maths/math";
+import { IVector3Like } from "babylonjs/Maths/math.like";
+import { Nullable } from "babylonjs/types";
+import { CreateNavMeshResult, GeneratorIntermediates, INavMeshParametersV2, RecastInjection } from "babylonjs-addons/navigation/types";
+/**
+ * Navigation plugin for Babylon.js. It is a simple wrapper around the recast-navigation-js library. Not all features are implemented.
+ * @remarks This plugin provides navigation mesh generation and pathfinding capabilities using the recast-navigation-js library
+ * @remarks It supports both single-threaded and multi-threaded generation of navigation meshes.
+ * @remarks The plugin can be used to create navigation meshes from meshes in a scene, compute paths, and manage crowd agents, etc.
+ * @remarks It also provides methods for creating obstacles and querying the navigation mesh.
+ * @see https://github.com/isaac-mason/recast-navigation-js
+ */
+export class RecastNavigationJSPluginV2 implements INavigationEnginePlugin {
+    /**
+     *  Creates a navigation mesh - will be injected by the factory
+     * @param meshes array of all the geometry used to compute the navigation mesh
+     * @param parameters bunch of parameters used to filter geometry
+     * @returns the created navmesh and navmesh query
+     */
+    createNavMeshImpl: (meshes: Array<Mesh>, parameters: INavMeshParametersV2) => CreateNavMeshResult;
+    /**
+     * Creates a navigation mesh - will be injected by the factory
+     * @param meshes array of all the geometry used to compute the navigation mesh
+     * @param parameters bunch of parameters used to filter geometry
+     * @returns the created navmesh and navmesh query
+     */
+    createNavMeshAsyncImpl: (meshes: Array<Mesh>, parameters: INavMeshParametersV2) => Promise<CreateNavMeshResult>;
+    /**
+     * recast-navigation-js injection
+     */
+    bjsRECAST: RecastInjection;
+    /**
+     * plugin name
+     */
+    name: string;
+    /**
+     * the navmesh created
+     */
+    navMesh?: any;
+    /**
+     * The navmesh query created from the navmesh
+     * @remarks This is used to query the navmesh for pathfinding and other navigation tasks
+     */
+    get navMeshQuery(): any;
+    private _navMeshQuery;
+    /**
+     * Intermediates generated during the navmesh creation
+     * @remarks This is used for debugging and visualization purposes.
+     * @remarks You have access to vertices, indices and vertex colors to visusalize the navmesh creation process.
+     * @remarks This is only available if the `keepIntermediates` parameter is set
+     * @remarks to true during navmesh generation.
+     */
+    private _intermediates?;
+    /**
+     * Gets the intermediates generated during the navmesh creation
+     * @returns The generator intermediates, or undefined if not available
+     */
+    get intermediates(): GeneratorIntermediates | undefined;
+    /**
+     * Tile cache used for tiled navigation meshes
+     * @remarks This is used to store and manage tiles of the navigation mesh for efficient path and when obstacles are used.
+     */
+    private _tileCache?;
+    /**
+     * Gets the tile cache used for tiled navigation meshes
+     * @returns The tile cache instance, or undefined if not available
+     */
+    get tileCache(): any | undefined;
+    private _maximumSubStepCount;
+    private _timeStep;
+    private _timeFactor;
+    private _crowd?;
+    /**
+     * Creates a RecastNavigationJSPluginV2 instance
+     * @param recastInjection The recast-navigation-js injection containing core and generators
+     */
+    constructor(recastInjection?: RecastInjection);
+    /**
+     * Set the time step of the navigation tick update.
+     * Default is 1/60.
+     * A value of 0 will disable fixed time update
+     * @param newTimeStep the new timestep to apply to this world.
+     */
+    setTimeStep(newTimeStep?: number): void;
+    /**
+     * Get the time step of the navigation tick update.
+     * @returns the current time step
+     */
+    getTimeStep(): number;
+    /**
+     * If delta time in navigation tick update is greater than the time step
+     * a number of sub iterations are done. If more iterations are need to reach deltatime
+     * they will be discarded.
+     * A value of 0 will set to no maximum and update will use as many substeps as needed
+     * @param newStepCount the maximum number of iterations
+     */
+    setMaximumSubStepCount(newStepCount?: number): void;
+    /**
+     * Get the maximum number of iterations per navigation tick update
+     * @returns the maximum number of iterations
+     */
+    getMaximumSubStepCount(): number;
+    /**
+     * Time factor applied when updating crowd agents (default 1). A value of 0 will pause crowd updates.
+     * @param value the time factor applied at update
+     */
+    set timeFactor(value: number);
+    /**
+     * Get the time factor used for crowd agent update
+     * @returns the time factor
+     */
+    get timeFactor(): number;
+    /**
+     * Creates a navigation mesh - will be injected by the factory
+     * @param meshes array of all the geometry used to compute the navigation mesh
+     * @param parameters bunch of parameters used to filter geometry
+     * @returns the created navmesh and navmesh query
+     * @throws Error if the function is not injected yet or if the navmesh is not created
+     */
+    createNavMesh(meshes: Array<Mesh>, parameters: INavMeshParametersV2): CreateNavMeshResult;
+    /**
+     * Creates a navigation mesh asynchronously - will be injected by the factory
+     * @param meshes array of all the geometry used to compute the navigation mesh
+     * @param parameters bunch of parameters used to filter geometry
+     * @returns the created navmesh and navmesh query
+     * @throws Error if the function is not injected yet or if the navmesh is not created
+     */
+    createNavMeshAsync(meshes: Array<Mesh>, parameters: INavMeshParametersV2): Promise<CreateNavMeshResult>;
+    /**
+     * Create a navigation mesh debug mesh
+     * @param scene is where the mesh will be added
+     * @returns debug display mesh
+     */
+    createDebugNavMesh(scene: Scene): Mesh;
+    /**
+     * Get a navigation mesh constrained position, closest to the parameter position
+     * @param position world position
+     * @returns the closest point to position constrained by the navigation mesh
+     */
+    getClosestPoint(position: IVector3Like, options?: {
+        /**
+         * The polygon filter to apply to the query.
+         */
+        filter?: any;
+        /**
+         * Half extents for the search box
+         */
+        halfExtents?: IVector3Like;
+    }): Vector3;
+    /**
+     * Get a navigation mesh constrained position, closest to the parameter position
+     * @param position world position
+     * @param result output the closest point to position constrained by the navigation mesh
+     */
+    getClosestPointToRef(position: IVector3Like, result: Vector3, options?: {
+        /**
+         * The polygon filter to apply to the query.
+         */
+        filter?: any;
+        /**
+         * Half extents for the search box
+         */
+        halfExtents?: IVector3Like;
+    }): void;
+    /**
+     * Get a navigation mesh constrained position, within a particular radius
+     * @param position world position
+     * @param maxRadius the maximum distance to the constrained world position
+     * @returns the closest point to position constrained by the navigation mesh
+     */
+    getRandomPointAround(position: IVector3Like, maxRadius: number, options?: {
+        startRef?: number;
+        /**
+         * The polygon filter to apply to the query.
+         */
+        filter?: any;
+        /**
+         * Half extents for the search box
+         */
+        halfExtents?: IVector3Like;
+    }): Vector3;
+    /**
+     * Get a navigation mesh constrained position, within a particular radius
+     * @param position world position
+     * @param maxRadius the maximum distance to the constrained world position
+     * @param result output the closest point to position constrained by the navigation mesh
+     */
+    getRandomPointAroundToRef(position: IVector3Like, maxRadius: number, result: Vector3, options?: {
+        startRef?: number;
+        /**
+         * The polygon filter to apply to the query.
+         */
+        filter?: any;
+        /**
+         * Half extents for the search box
+         */
+        halfExtents?: IVector3Like;
+    }): void;
+    /**
+     * Compute the final position from a segment made of destination-position
+     * @param position position to start from
+     * @param destination position to go to
+     * @param startRef the reference id of the start polygon
+     * @param options options for the function
+     * @returns the resulting point along the navmesh
+     */
+    moveAlong(position: IVector3Like, destination: IVector3Like, startRef?: number, options?: {
+        /**
+         * The polygon filter to apply to the query.
+         */
+        filter?: any;
+        /**
+         * The maximum number of polygons the output visited array can hold.
+         */
+        maxVisitedSize?: number;
+    }): Vector3;
+    /**
+     * Compute the final position from a segment made of destination-position
+     * @param position world position
+     * @param destination world position
+     * @param result output the resulting point along the navmesh
+     * @param startRef the reference id of the start polygon.
+     * @param options options for the function
+     */
+    moveAlongToRef(position: IVector3Like, destination: IVector3Like, result: Vector3, startRef?: number, options?: {
+        /**
+         * The polygon filter to apply to the query.
+         */
+        filter?: any;
+        maxVisitedSize?: number;
+    }): void;
+    /**
+     * Compute a navigation path from start to end. Returns an empty array if no path can be computed
+     * Path is straight.
+     * @param start world position
+     * @param end world position
+     * @param options options for the function
+     * @returns array containing world position composing the path
+     */
+    computePath(start: IVector3Like, end: IVector3Like, options?: {
+        /**
+         * The polygon filter to apply to the query.
+         */
+        filter?: any;
+        /**
+         * Half extents for the search box
+         */
+        halfExtents?: IVector3Like;
+        maxPathPolys?: number;
+        maxStraightPathPoints?: number;
+    }): Vector3[];
+    /**
+     * Creates a navigation mesh - will be injected by the factory
+     * @param start the start position of the navmesh
+     * @param end the end position of the navmesh
+     * @param options options to configure the path computation
+     * @returns array containing world position composing the path
+     */
+    computePathSmooth(start: Vector3, end: Vector3, options?: {
+        /**
+         * The polygon filter to apply to the query.
+         */
+        filter?: any;
+        /**
+         * Half extents for the search box
+         */
+        halfExtents?: IVector3Like;
+        maxPathPolys?: number;
+        maxSmoothPathPoints?: number;
+        stepSize?: number;
+        slop?: number;
+    }): Vector3[];
+    /**
+     * Create a new Crowd so you can add agents
+     * @param maxAgents the maximum agent count in the crowd
+     * @param maxAgentRadius the maximum radius an agent can have
+     * @param scene to attach the crowd to
+     * @returns the crowd you can add agents to
+     */
+    createCrowd(maxAgents: number, maxAgentRadius: number, scene: Scene): ICrowd;
+    /**
+     * Set the Bounding box extent for doing spatial queries (getClosestPoint, getRandomPointAround, ...)
+     * The queries will try to find a solution within those bounds
+     * default is (1,1,1)
+     * @param extent x,y,z value that define the extent around the queries point of reference
+     */
+    setDefaultQueryExtent(extent: IVector3Like): void;
+    /**
+     * Get the Bounding box extent specified by setDefaultQueryExtent
+     * @returns the box extent values
+     */
+    getDefaultQueryExtent(): Vector3;
+    /**
+     * Get the Bounding box extent result specified by setDefaultQueryExtent
+     * @param result output the box extent values
+     */
+    getDefaultQueryExtentToRef(result: Vector3): void;
+    /**
+     * build the navmesh from a previously saved state using getNavmeshData
+     * @param data the Uint8Array returned by getNavmeshData
+     */
+    buildFromNavmeshData(data: Uint8Array): void;
+    /**
+     * returns the navmesh data that can be used later. The navmesh must be built before retrieving the data
+     * @returns data the Uint8Array that can be saved and reused
+     */
+    getNavmeshData(): Uint8Array;
+    /**
+     * build the tile cache from a previously saved state using getTileCacheData
+     * @param tileCacheData the data returned by getTileCacheData
+     * @param tileCacheMeshProcess optional process to apply to each tile created
+     */
+    buildFromTileCacheData(tileCacheData: Uint8Array, tileCacheMeshProcess?: any): void;
+    /**
+     * returns the tile cache data that can be used later. The tile cache must be built before retrieving the data
+     * @returns the tile cache data that can be used later. The tile cache must be built before retrieving the data
+     * @throws Error if there is no any generated
+     * @remarks The returned data can be used to rebuild the tile cache later using buildFromTileCacheData
+     */
+    getTileCacheData(): Uint8Array;
+    /**
+     * Disposes
+     */
+    dispose(): void;
+    /**
+     * Creates a cylinder obstacle and add it to the navigation
+     * @param position world position
+     * @param radius cylinder radius
+     * @param height cylinder height
+     * @param doNotWaitForCacheUpdate if true the function will not wait for the tile cache to be fully updated before returning
+     * @returns the obstacle freshly created
+     */
+    addCylinderObstacle(position: IVector3Like, radius: number, height: number, doNotWaitForCacheUpdate?: boolean): Nullable<IObstacle>;
+    /**
+     * Creates an oriented box obstacle and add it to the navigation
+     * @param position world position
+     * @param extent box size
+     * @param angle angle in radians of the box orientation on Y axis
+     * @param doNotWaitForCacheUpdate if true the function will not wait for the tile cache to be fully updated before returning
+     * @returns the obstacle freshly created
+     */
+    addBoxObstacle(position: IVector3Like, extent: IVector3Like, angle: number, doNotWaitForCacheUpdate?: boolean): Nullable<IObstacle>;
+    /**
+     * Removes an obstacle created by addCylinderObstacle or addBoxObstacle
+     * @param obstacle obstacle to remove from the navigation
+     * @param doNotWaitForCacheUpdate if true the function will not wait for the tile cache to be fully updated before returning
+     *
+     */
+    removeObstacle(obstacle: IObstacle, doNotWaitForCacheUpdate?: boolean): void;
+    /**
+     * If this plugin is supported
+     * @returns true if plugin is supported
+     */
+    isSupported(): boolean;
+    /**
+     * Returns the seed used for randomized functions like `getRandomPointAround`
+     * @returns seed number
+     */
+    getRandomSeed(): number;
+    /**
+     * Set the seed used for randomized functions like `getRandomPointAround`
+     * @param seed number used as seed for random functions
+     */
+    setRandomSeed(seed: number): void;
+    /**
+     * Perform a raycast on the navmesh
+     * @param start start position
+     * @param end end position
+     * @returns if a direct path exists between start and end, and the hit point if any
+     */
+    raycast(start: IVector3Like, end: IVector3Like): {
+        hit: boolean;
+        hitPoint?: undefined;
+    } | {
+        hit: boolean;
+        hitPoint: Vector3;
+    };
+    /**
+     * Compute the final position from a segment made of destination-position, and return the height of the polygon
+     * This is a more sophisiticated version of moveAlong that will use the height of the polygon at the end position
+     * @param position world position to start from
+     * @param velocity wvelocity of the movement
+     * @param options options for the function
+     * @returns the resulting point along the navmesh, the polygon reference id and the height of the polygon
+     */
+    moveAlongWithVelocity(position: IVector3Like, velocity: IVector3Like, options?: {
+        /**
+         * The polygon filter to apply to the query.
+         */
+        filter?: any;
+        /**
+         * Half extents for the search box
+         */
+        halfExtents?: IVector3Like;
+        /**
+         * The maximum number of polygons the output visited array can hold.
+         */
+        maxVisitedSize?: number;
+    }): {
+        position: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        polyRef: number;
+        height: number;
+    };
+    /**
+     * Handles common post-processing and validation of navmesh creation results
+     * @param result The partial result from navmesh creation
+     * @returns The validated and complete CreateNavMeshresult
+     */
+    private _processNavMeshResult;
+    private _preprocessParameters;
+}
+
+}
+declare module "babylonjs-addons/navigation/plugin/RecastJSCrowd" {
+
+import { IVector3Like } from "babylonjs/Maths/math.like";
+import { TransformNode } from "babylonjs/Meshes/transformNode";
+import { ICrowd } from "babylonjs/Navigation/INavigationEngine";
+import { Vector3 } from "babylonjs/Maths/math.vector";
+import { Observable } from "babylonjs/Misc/observable";
+import { Scene } from "babylonjs/scene";
+import { RecastNavigationJSPluginV2 } from "babylonjs-addons/navigation/plugin/RecastNavigationJSPlugin";
+import { IAgentParametersV2 } from "babylonjs-addons/navigation/types";
+/**
+ * Recast Detour crowd implementation
+ * This class provides methods to manage a crowd of agents, allowing them to navigate a navigation mesh.
+ * It supports adding agents, updating their parameters, moving them to destinations, and checking their states.
+ * The crowd is updated in the scene's animation loop, and it notifies observers when agents reach their destinations.
+ */
+export class RecastJSCrowd implements ICrowd {
+    /**
+     * Recast plugin
+     */
+    get navigationPlugin(): RecastNavigationJSPluginV2;
+    /**
+     * Link to the detour crowd
+     */
+    get recastCrowd(): any;
+    /**
+     * One transform per agent
+     */
+    get transforms(): TransformNode[];
+    /**
+     * All agents created
+     */
+    get agents(): readonly number[];
+    /**
+     * Agents reach radius
+     */
+    get reachRadii(): readonly number[];
+    private _navigationPlugin;
+    private _recastCrowd;
+    private _transforms;
+    private _agents;
+    private _reachRadii;
+    /**
+     * true when a destination is active for an agent and notifier hasn't been notified of reach
+     */
+    private _agentDestinationArmed;
+    /**
+     * agent current target
+     */
+    private _agentDestination;
+    /**
+     * Link to the scene is kept to unregister the crowd from the scene
+     */
+    private _scene;
+    private _engine;
+    /**
+     * Observer for crowd updates
+     */
+    private _onBeforeAnimationsObserver;
+    /**
+     * Fires each time an agent is in reach radius of its destination
+     */
+    onReachTargetObservable: Observable<{
+        /**
+         *
+         */
+        agentIndex: number;
+        /**
+         *
+         */
+        destination: Vector3;
+    }>;
+    /**
+     * Constructor
+     * @param plugin recastJS plugin
+     * @param maxAgents the maximum agent count in the crowd
+     * @param maxAgentRadius the maximum radius an agent can have
+     * @param scene to attach the crowd to
+     * @returns the crowd you can add agents to
+     */
+    constructor(plugin: RecastNavigationJSPluginV2, maxAgents: number, maxAgentRadius: number, scene: Scene);
+    /**
+     * Add a new agent to the crowd with the specified parameter a corresponding transformNode.
+     * You can attach anything to that node. The node position is updated in the scene update tick.
+     * @param pos world position that will be constrained by the navigation mesh
+     * @param parameters agent parameters
+     * @param transform hooked to the agent that will be update by the scene
+     * @returns agent index
+     */
+    addAgent(pos: IVector3Like, parameters: IAgentParametersV2, transform: TransformNode): number;
+    /**
+     * Returns the agent position in world space
+     * @param index agent index returned by addAgent
+     * @returns world space position
+     */
+    getAgentPosition(index: number): Vector3;
+    /**
+     * Returns the agent position result in world space
+     * @param index agent index returned by addAgent
+     * @param result output world space position
+     */
+    getAgentPositionToRef(index: number, result: Vector3): void;
+    /**
+     * Returns the agent velocity in world space
+     * @param index agent index returned by addAgent
+     * @returns world space velocity
+     */
+    getAgentVelocity(index: number): Vector3;
+    /**
+     * Returns the agent velocity result in world space
+     * @param index agent index returned by addAgent
+     * @param result output world space velocity
+     */
+    getAgentVelocityToRef(index: number, result: Vector3): void;
+    /**
+     * Returns the agent next target point on the path
+     * @param index agent index returned by addAgent
+     * @returns world space position
+     */
+    getAgentNextTargetPath(index: number): Vector3;
+    /**
+     * Returns the agent next target point on the path
+     * @param index agent index returned by addAgent
+     * @param result output world space position
+     */
+    getAgentNextTargetPathToRef(index: number, result: Vector3): void;
+    /**
+     * Gets the agent state
+     * @param index agent index returned by addAgent
+     * @returns agent state, 0 = DT_CROWDAGENT_STATE_INVALID, 1 = DT_CROWDAGENT_STATE_WALKING, 2 = DT_CROWDAGENT_STATE_OFFMESH
+     */
+    getAgentState(index: number): number;
+    /**
+     * returns true if the agent in over an off mesh link connection
+     * @param index agent index returned by addAgent
+     * @returns true if over an off mesh link connection
+     */
+    overOffmeshConnection(index: number): boolean;
+    /**
+     * Asks a particular agent to go to a destination. That destination is constrained by the navigation mesh
+     * @param index agent index returned by addAgent
+     * @param destination targeted world position
+     */
+    agentGoto(index: number, destination: IVector3Like): void;
+    /**
+     * Teleport the agent to a new position
+     * @param index agent index returned by addAgent
+     * @param destination targeted world position
+     */
+    agentTeleport(index: number, destination: IVector3Like): void;
+    /**
+     * Update agent parameters
+     * @param index agent index returned by addAgent
+     * @param parameters agent parameters
+     */
+    updateAgentParameters(index: number, parameters: IAgentParametersV2): void;
+    /**
+     * remove a particular agent previously created
+     * @param index agent index returned by addAgent
+     */
+    removeAgent(index: number): void;
+    /**
+     * get the list of all agents attached to this crowd
+     * @returns list of agent indices
+     */
+    getAgents(): number[];
+    /**
+     * Tick update done by the Scene. Agent position/velocity/acceleration is updated by this function
+     * @param deltaTime in seconds
+     */
+    update(deltaTime: number): void;
+    /**
+     * Set the Bounding box extent for doing spatial queries (getClosestPoint, getRandomPointAround, ...)
+     * The queries will try to find a solution within those bounds
+     * default is (1,1,1)
+     * @param extent x,y,z value that define the extent around the queries point of reference
+     */
+    setDefaultQueryExtent(extent: IVector3Like): void;
+    /**
+     * Get the Bounding box extent specified by setDefaultQueryExtent
+     * @returns the box extent values
+     */
+    getDefaultQueryExtent(): Vector3;
+    /**
+     * Get the Bounding box extent result specified by setDefaultQueryExtent
+     * @param result output the box extent values
+     */
+    getDefaultQueryExtentToRef(result: Vector3): void;
+    /**
+     * Get the next corner points composing the path (max 4 points)
+     * @param index agent index returned by addAgent
+     * @returns array containing world position composing the path
+     */
+    getCorners(index: number): Vector3[];
+    /**
+     * Release all resources
+     */
+    dispose(): void;
+}
+
+}
+declare module "babylonjs-addons/navigation/generator/injection" {
+import { RecastNavigationJSPluginV2 } from "babylonjs-addons/navigation/plugin/RecastNavigationJSPlugin";
+/**
+ * Injects the navigation mesh generation methods into the navigation plugin.
+ * @param navigationPlugin The navigation plugin to inject the methods into.
+ */
+export function InjectGenerators(navigationPlugin: RecastNavigationJSPluginV2): void;
+
+}
+declare module "babylonjs-addons/navigation/generator/index" {
+export * from "babylonjs-addons/navigation/generator/generator.common";
+export * from "babylonjs-addons/navigation/generator/generator.single-thread";
+export * from "babylonjs-addons/navigation/generator/injection";
+
+}
+declare module "babylonjs-addons/navigation/generator/generator.worker" {
+/**
+ * IMPORTANT!
+ * This file is still under construction and will change in the future.
+ * Workers are not yet supported.
+ * For more info visit: https://forum.babylonjs.com/t/replacing-recastjs-with-recast-navigation-js/56003/46
+ */
+
+import { Mesh } from "babylonjs/Meshes/mesh";
+import { INavMeshParametersV2 } from "babylonjs-addons/navigation/types";
+/**
+ * Builds a any and any from meshes using provided parameters.
+ * @param meshes The array of meshes used to create the any
+ * @param parameters The parameters used to configure the any generation.
+ * @param workerOptions Options for the worker, including a completion callback and the worker instance.
+ * @throws Error if the any data is invalid or cannot be deserialized.
+ */
+export function GenerateNavMeshWithWorker(meshes: Array<Mesh>, parameters: INavMeshParametersV2, workerOptions: {
+    /**
+     * Completion callback that is called when the any generation is complete.
+     * @param navMesh The generated any
+     * @param navMeshQuery The any associated with the generated any
+     * @param tileCache Optional any if tile cache generation was used.
+     */
+    completion: (navMesh: any, navMeshQuery: any, tileCache?: any) => void;
+    /**
+     *  Worker instance used for asynchronous any generation.
+     */
+    worker: Worker;
+}): void;
+
+}
+declare module "babylonjs-addons/navigation/generator/generator.single-thread" {
+import { Mesh } from "babylonjs/Meshes/mesh";
+import { INavMeshParametersV2 } from "babylonjs-addons/navigation/types";
+/**
+ * Builds a NavMesh and NavMeshQuery from meshes using provided parameters.
+ * @param meshes The array of meshes used to create the NavMesh.
+ * @param parameters The parameters used to configure the NavMesh generation.
+ * @returns An object containing the NavMesh and NavMeshQuery.
+ * @remarks This function generates a NavMesh based on the provided meshes and parameters.
+ * It supports different configurations such as solo, tiled, and tile cache nav meshes.
+ * If you need obstacles, ensure that `maxObstacles` is set to a value greater than 0.
+ * Recommended values for `tileSize` are between 32 and 64 when using obstacles/tile cache.
+ * If you need a tiled nav mesh, ensure that `tileSize` is set to a value greater than 0.
+ * @throws Error if the NavMesh data is invalid or cannot be deserialized.
+ */
+export function GenerateNavMesh(meshes: Array<Mesh>, parameters: INavMeshParametersV2): {
+    navMesh: any;
+    intermediates: any;
+    navMeshQuery: any;
+    tileCache: any;
+};
+
+}
+declare module "babylonjs-addons/navigation/generator/generator.common" {
+
+/**
+ *  Builds a NavMesh and NavMeshQuery from serialized data.
+ *  @param data The serialized NavMesh data.
+ *  @returns An object containing the NavMesh and NavMeshQuery.
+ *  @remarks This function deserializes the NavMesh data and creates a NavMeshQuery
+ *  instance for querying the NavMesh.
+ *  @throws Error if the NavMesh data is invalid or cannot be deserialized.
+ */
+export function BuildFromNavmeshData(data: Uint8Array): {
+    navMesh: any;
+    navMeshQuery: any;
+    tileCache: undefined;
+};
+/**
+ * Builds a TileCache and NavMeshQuery from serialized data.
+ * @param data The serialized TileCache data.
+ * @param tileCacheMeshProcess Optional function to process the TileCache mesh.
+ * @returns An object containing the TileCache, NavMesh, and NavMeshQuery.
+ */
+export function BuildFromTileCacheData(data: Uint8Array, tileCacheMeshProcess: any): {
+    navMesh: any;
+    navMeshQuery: any;
+    tileCache: any;
+};
+
+}
+declare module "babylonjs-addons/navigation/factory/index" {
+export * from "babylonjs-addons/navigation/factory/factory.single-thread";
+
+}
+declare module "babylonjs-addons/navigation/factory/factory.worker" {
+import { RecastNavigationJSPluginV2 } from "babylonjs-addons/navigation/plugin/RecastNavigationJSPlugin";
+/**
+ * Creates a navigation plugin for the given scene using a worker.
+ * @returns A promise that resolves to the created navigation plugin.
+ * @remarks This function initializes the Recast module and sets up the navigation plugin to use a worker.
+ * The worker is used to handle the creation of the navigation mesh asynchronously.
+ * The `createNavMesh` method is not supported in worker mode, use `createNavMeshAsync` instead.
+ */
+export function CreateNavigationPluginWorkerAsync(): Promise<RecastNavigationJSPluginV2>;
+
+}
+declare module "babylonjs-addons/navigation/factory/factory.single-thread" {
+import { RecastNavigationJSPluginV2 } from "babylonjs-addons/navigation/plugin/RecastNavigationJSPlugin";
+/**
+ * Creates a navigation plugin for the given scene.
+ * @returns A promise that resolves to the created navigation plugin.
+ * @remarks This function initializes the Recast module and sets up the navigation plugin.
+ */
+export function CreateNavigationPluginAsync(): Promise<RecastNavigationJSPluginV2>;
+
+}
+declare module "babylonjs-addons/navigation/factory/common" {
+import { RecastInjection } from "babylonjs-addons/navigation/types";
+/**
+ * Gets the RecastInjection instance (reference to the recast-navigation-js library).
+ * @returns The RecastInjection instance
+ * @throws Error if Recast is not initialized
+ */
+export function GetRecast(): RecastInjection;
+/**
+ * Sets the RecastInjection instance (reference to the recast-navigation-js library).
+ * @param recast The RecastInjection instance to set
+ */
+export function SetRecast(recast: RecastInjection): void;
+/**
+ * Initialize the Manifold library
+ * @param version defines the version of the library to use, default is "0.43.0"
+ * @param options defines the options to use to initialize the library
+ */
+export function InitRecast(version?: string, options?: {
+    instance: RecastInjection;
+}): Promise<void>;
+
+}
+declare module "babylonjs-addons/navigation/debug/simple-debug" {
+
+import { Scene } from "babylonjs/scene";
+import { Node } from "babylonjs/node";
+import { Mesh } from "babylonjs/Meshes/mesh";
+/**
+ * Creates a debug mesh for visualizing a any in the scene.
+ * @param navMesh The any to visualize.
+ * @param scene The scene in which to create the debug mesh.
+ * @param parent Optional parent node for the debug mesh.
+ * @param flags Poly flags to filter by, defaults to undefined to include all polys
+ * @returns The created debug mesh.
+ */
+export function CreateDebugNavMesh(navMesh: any, scene: Scene, parent?: Node, flags?: number): Mesh;
+
+}
+declare module "babylonjs-addons/navigation/debug/index" {
+export * from "babylonjs-addons/navigation/debug/NavigationDebugger";
+export * from "babylonjs-addons/navigation/debug/simple-debug";
+
+}
+declare module "babylonjs-addons/navigation/debug/NavigationDebugger" {
+
+import { GreasedLineMaterialOptions } from "babylonjs/Materials/GreasedLine/greasedLineMaterialInterfaces";
+import { StandardMaterial } from "babylonjs/Materials/standardMaterial";
+import { GreasedLineMeshOptions } from "babylonjs/Meshes/GreasedLine/greasedLineBaseMesh";
+import { TransformNode } from "babylonjs/Meshes/transformNode";
+import { Scene } from "babylonjs/scene";
+import { GeneratorIntermediates } from "babylonjs-addons/navigation/types";
+export const DebugLayerOption: {
+    HEIGHTFIELD_SOLID: string;
+    HEIGHTFIELD_WALKABLE: string;
+    COMPACT_HEIGHTFIELD_SOLID: string;
+    COMPACT_HEIGHTFIELD_REGIONS: string;
+    COMPACT_HEIGHTFIELD_DISTANCE: string;
+    RAW_CONTOURS: string;
+    CONTOURS: string;
+    POLY_MESH: string;
+    POLY_MESH_DETAIL: string;
+    NAVMESH: string;
+    NAVMESH_BV_TREE: string;
+};
+export type DebugLayerOptions = (typeof DebugLayerOption)[keyof typeof DebugLayerOption];
+/**
+ * NavigationDebugger is a utility class for visualizing navigation meshes and related data in a Babylon.js scene.
+ * It provides methods to draw various navigation-related primitives such as points, lines, triangles, and quads.
+ * It also supports drawing heightfields, compact heightfields, contours, poly meshes, and nav meshes.
+ */
+export class NavigationDebugger {
+    private _scene;
+    /**
+     *  The name of the debug mesh used for navigation debugging.
+     *  This is used to group all navigation debug meshes under a single name for easier management
+     */
+    static NAV_MESH_DEBUG_NAME: string;
+    /**
+     * The name of the debug mesh used for visualization of the navigation mesh using points.
+     */
+    static NAV_MESH_DEBUG_NAME_POINTS: string;
+    /**
+     * The name of the debug mesh used for visualization of the navigation mesh using triangles.
+     */
+    static NAV_MESH_DEBUG_NAME_TRIS: string;
+    /**
+     * The name of the debug mesh used for visualization of the navigation mesh using quads.
+     */
+    static NAV_MESH_DEBUG_NAME_QUADS: string;
+    /**
+     * The name of the debug mesh used for visualization of the navigation mesh using lines.
+     */
+    static NAV_MESH_DEBUG_NAME_LINES: string;
+    /**
+     * The material used for rendering triangles in the navigation debug visualization.
+     */
+    triMaterial: StandardMaterial;
+    /**
+     * The material used for rendering points in the navigation debug visualization.
+     */
+    pointMaterial: StandardMaterial;
+    /**
+     * The list of line materials used in the navigation debug visualization.
+     */
+    lineMaterials: StandardMaterial[];
+    /**
+     * The parent node for the debug drawer.
+     */
+    debugDrawerParentNode: TransformNode;
+    /**
+     * * Gets or sets the primitive types to be drawn by the debug drawer.
+     * * This allows you to control which types of primitives (points, lines, tris, quads) are rendered in the navigation debug visualization.
+     * * The default value is `["points", "lines", "tris", "quads"]`.
+     * * You can modify this property to include or exclude specific primitive types based on your debugging needs.
+     * @returns An array of primitive types that the debug drawer will render.
+     */
+    get primitiveTypes(): any;
+    set primitiveTypes(value: any);
+    private _lineMaterialOptions;
+    private _pointMesh;
+    private _debugDrawerUtils;
+    private _primitiveTypes;
+    constructor(_scene: Scene, options?: {
+        parent?: {
+            node?: TransformNode | string;
+        };
+        primitiveTypes?: any;
+        materials?: {
+            triMaterial?: StandardMaterial;
+            pointMaterial?: StandardMaterial;
+            lineMaterialOptions: {
+                greasedLineMaterialOptions: Partial<GreasedLineMaterialOptions>;
+                greasedLineMeshOptions: Partial<GreasedLineMeshOptions>;
+            };
+        };
+    });
+    /**
+     * Resets the debug drawer by disposing of all child meshes in the debug drawer parent node.
+     * This is useful for clearing the debug visualization before drawing new primitives.
+     */
+    clear(): void;
+    /**
+     * Disposes of the debug drawer, including all meshes and materials used for rendering.
+     * This method should be called when the debug drawer is no longer needed to free up resources.
+     */
+    dispose(): void;
+    /**
+     * This method iterates through the provided primitives and draws them based on their type.
+     * It supports drawing points, lines, triangles, and quads, depending on the primitive type.
+     * @param primitives An array of debug drawer primitives to be drawn.
+     * @param options Optional parameters to control the drawing behavior, such as whether to join meshes.
+     */
+    drawPrimitives(primitives: any, options?: {
+        joinMeshes?: boolean;
+    }): void;
+    /**
+     * Draws a heightfield as solid using the debug drawer utilities.
+     * @param hf The heightfield to draw as solid.
+     */
+    drawHeightfieldSolid(hf: any): void;
+    /**
+     * Draws a heightfield as walkable using the debug drawer utilities.
+     * @param hf The heightfield to draw as walkable.
+     */
+    drawHeightfieldWalkable(hf: any): void;
+    /**
+     * Draws a compact heightfield as solid using the debug drawer utilities.
+     * @param chf The compact heightfield to draw as solid.
+     */
+    drawCompactHeightfieldSolid(chf: any): void;
+    /**
+     * Draws the regions of a compact heightfield using the debug drawer utilities.
+     * @param chf The compact heightfield to draw regions for.
+     */
+    drawCompactHeightfieldRegions(chf: any): void;
+    /**
+     * Draws the distance field of a compact heightfield using the debug drawer utilities.
+     * @param chf The compact heightfield to draw the distance for.
+     */
+    drawCompactHeightfieldDistance(chf: any): void;
+    /**
+     * Draws a heightfield layer using the debug drawer utilities.
+     * @param layer The heightfield layer to draw.
+     * @param idx The index of the layer to draw.
+     */
+    drawHeightfieldLayer(layer: any, idx: number): void;
+    /**
+     * Draws the layers of a heightfield using the debug drawer utilities.
+     * @param lset The heightfield layer set containing the layers to draw.
+     */
+    drawHeightfieldLayers(lset: any): void;
+    /**
+     * Draws the region connections of a any using the debug drawer utilities.
+     * @param cset any to draw
+     * @param alpha The alpha value for the drawn contours, default is 1.
+     */
+    drawRegionConnections(cset: any, alpha?: number): void;
+    /**
+     * Draws raw contours from a any using the debug drawer utilities.
+     * @param cset any to draw
+     * @param alpha The alpha value for the drawn contours, default is 1.
+     */
+    drawRawContours(cset: any, alpha?: number): void;
+    /**
+     * Draws contours from a any using the debug drawer utilities.
+     * @param cset any to draw
+     * @param alpha The alpha value for the drawn contours, default is 1.
+     */
+    drawContours(cset: any, alpha?: number): void;
+    /**
+     * Draws a poly mesh using the debug drawer utilities.
+     * @param mesh any to draw
+     */
+    drawPolyMesh(mesh: any): void;
+    /**
+     * Draws a poly mesh detail using the debug drawer utilities.
+     * @param dmesh any to draw
+     */
+    drawPolyMeshDetail(dmesh: any): void;
+    /**
+     * Draws a any using the debug drawer utilities.
+     * @param mesh any to draw
+     * @param flags Flags to control the drawing behavior, default is 0.
+     */
+    drawNavMesh(mesh: any, flags?: number): void;
+    /**
+     * Draws a any with closed list using the debug drawer utilities.
+     * @param mesh any to draw
+     * @param query any to use for drawing the closed list.
+     * @param flags Flags to control the drawing behavior, default is 0.
+     */
+    drawNavMeshWithClosedList(mesh: any, query: any, flags?: number): void;
+    /**
+     * Draws the nodes of a any using the debug drawer utilities.
+     * @param query any to use for drawing the nodes.
+     */
+    drawNavMeshNodes(query: any): void;
+    /**
+     * Draws the bounding volume tree of a any using the debug drawer utilities.
+     * @param mesh any to draw the bounding volume tree for.
+     */
+    drawNavMeshBVTree(mesh: any): void;
+    /**
+     * Draws the portals of a any using the debug drawer utilities.
+     * @param mesh any to draw the portals for.
+     */
+    drawNavMeshPortals(mesh: any): void;
+    /**
+     * Draws polygons of a any with specific flags using the debug drawer utilities.
+     * @param mesh any to draw the polygons with specific flags.
+     * @param flags The flags to filter the polygons to be drawn.
+     * @param col The color to use for the drawn polygons, represented as a number.
+     */
+    drawNavMeshPolysWithFlags(mesh: any, flags: number, col: number): void;
+    /**
+     * Draws polygons of a any with specific reference and color using the debug drawer utilities.
+     * @param mesh any to draw the polygons with specific reference and color.
+     * @param ref The reference number of the polygons to be drawn.
+     * @param col The color to use for the drawn polygons, represented as a number.
+     */
+    drawNavMeshPoly(mesh: any, ref: number, col: number): void;
+    /**
+     *  Get the intermediates from the generator
+     *  @param intermediates - The generator intermediates
+     *  @returns An object containing lists of heightfields, compact heightfields, contour sets
+     */
+    getIntermediates: (intermediates: GeneratorIntermediates) => {
+        heightfieldList: any;
+        compactHeightfieldList: any;
+        contourSetList: any;
+        polyMeshList: any;
+        polyMeshDetailList: any;
+    };
+    /**
+     *  Draw debug information based on the selected option
+     *  @param navMesh - The navigation mesh to draw
+     *  @param intermediates - The generator intermediates containing the data to draw
+     *  @param scene - The scene to draw in
+     *  @param option - The debug drawer option to use
+     *  @remarks This method will reset the debug drawer before drawing.
+     */
+    draw(navMesh: any, intermediates: GeneratorIntermediates, scene: Scene, option: DebugLayerOptions): void;
+    private _drawPoints;
+    private _drawLines;
+    private _drawTris;
+    private _drawQuads;
+    /**
+     * Merge the debug meshes for better performance
+     */
+    private _joinDebugMeshes;
+    private _convertUnindexedToIndexed;
+}
+
+}
+declare module "babylonjs-addons/navigation/common/utils" {
+import { IVector3Like } from "babylonjs/Maths/math.like";
+import { Vector3 } from "babylonjs/Maths/math.vector";
+/**
+ * Utility function based on Chaikin's alogrithm for navigation path smoothing and segment generation.
+ * @param points Array of points to be smoothed, where each point is an object with x, y, and z properties.
+ * @param iterations Number of smoothing iterations to apply. Default 1.
+ * @returns A new array of smoothed points after applying the Chaikin's algorithm.
+ */
+export function GetChaikinSmoothPath(points: IVector3Like[], iterations?: number): IVector3Like[];
+/**
+ *  Generates a series of points that create an L-shaped path between each pair of points in the input navigation segment.
+ *  The path consists of a horizontal segment followed by a vertical segment, or vice versa,
+ *  depending on the relative distances between the x and z coordinates of the points.
+ * @param navSegment An array of Vector3 points representing the navigation segment.
+ * @returns An array of Vector3 points representing the L-shaped path.
+ */
+export function GetLShapedPath(navSegment: Vector3[]): Vector3[];
+
+}
+declare module "babylonjs-addons/navigation/common/tile-cache" {
+
+/**
+ * Creates a default tile cache mesh process function
+ * @param offMeshConnections offMeshConnections
+ * @param area the area to be set for each poly
+ * @param flags the flags to be set for each poly
+ * @returns the tile cache mesh process function
+ */
+export function CreateDefaultTileCacheMeshProcess(offMeshConnections?: any, area?: number, flags?: number): any;
+/**
+ * Waits until the tile cache is fully updated
+ * @param navMesh The any
+ * @param tileCache THe any
+ */
+export function WaitForFullTileCacheUpdate(navMesh: any, tileCache: any): void;
+
+}
+declare module "babylonjs-addons/navigation/common/smooth-path" {
+
+import { IVector3Like } from "babylonjs/Maths/math.like";
+import { Vector3 } from "babylonjs/Maths/math.vector";
+/**
+ * Compute a smooth navigation path from start to end. Returns an empty array if no path can be computed
+ * @param navMesh the navigation mesh to use
+ * @param navmeshQuery the navigation mesh query to use
+ * @param start world position
+ * @param end world position
+ * @param options options object
+ * @returns array containing world position composing the path
+ */
+export function ComputeSmoothPath(navMesh: any, navmeshQuery: any, start: IVector3Like, end: IVector3Like, options?: {
+    filter?: any;
+    halfExtents?: IVector3Like;
+    /**
+     * @default 256
+     */
+    maxPathPolys?: number;
+    /**
+     * @default 2048
+     */
+    maxSmoothPathPoints?: number;
+    /**
+     * @default 0.5
+     */
+    stepSize?: number;
+    /**
+     * @default 0.01
+     */
+    slop?: number;
+}): Vector3[];
+
+}
+declare module "babylonjs-addons/navigation/common/index" {
+export * from "babylonjs-addons/navigation/common/config";
+export * from "babylonjs-addons/navigation/common/convert";
+export * from "babylonjs-addons/navigation/common/getters";
+export * from "babylonjs-addons/navigation/common/smooth-path";
+export * from "babylonjs-addons/navigation/common/utils";
+export * from "babylonjs-addons/navigation/common/tile-cache";
+
+}
+declare module "babylonjs-addons/navigation/common/getters" {
+import { Mesh } from "babylonjs/Meshes/mesh";
+/**
+ *  Extracts positions and indices from an array of meshes.
+ *  @param meshes The array of meshes from which to extract positions and indices.
+ *  @returns A tuple containing a Float32Array of positions and a Uint32Array of
+ */
+export function GetPositionsAndIndices(meshes: Mesh[]): [positions: Float32Array, indices: Uint32Array];
+/**
+ * Reverses the order of vertices in each triangle (3 indices per face) to ensure
+ * that the winding order is consistent with the Recast Navigation requirements.
+ * This is necessary because Recast Navigation expects the indices to be in a specific winding order.
+ * @param meshOrIndices The mesh from which to extract indices or the indices themselves.
+ * @returns Array of indices with reversed winding order.
+ */
+export function GetReversedIndices(meshOrIndices: Mesh | Uint32Array | number[]): Uint32Array<ArrayBufferLike> | number[] | Int32Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | null;
+
+}
+declare module "babylonjs-addons/navigation/common/convert" {
+import { Vector3 } from "babylonjs/Maths/math.vector";
+import { ComputePathResult } from "babylonjs-addons/navigation/types";
+/**
+ *  Converts navigation path points to a Vector3 array.
+ *  @param navPath The navigation path containing points and success status.
+ *  @returns An array of Vector3 points representing the navigation path.
+ */
+export function ConvertNavPathPoints(navPath: ComputePathResult): Vector3[];
+
+}
+declare module "babylonjs-addons/navigation/common/config" {
+
+
+import { IAgentParametersV2, INavMeshParametersV2 } from "babylonjs-addons/navigation/types";
+export const DefaultMaxObstacles = 128;
+/**
+ * Creates a SoloNavMesh configuration based on the provided parameters.
+ * @param parameters The parameters used to configure the SoloNavMesh generation.
+ * @returns A configuration object for generating a SoloNavMesh.
+ * @see https://docs.recast-navigation-js.isaacmason.com/types/index.RecastConfig.html
+ */
+export function CreateSoloNavMeshConfig(parameters: INavMeshParametersV2): Partial<any>;
+/**
+ * Creates a TiledNavMesh configuration based on the provided parameters.
+ * @param parameters The parameters used to configure the TiledNavMesh generation.
+ * @returns A configuration object for generating a TiledNavMesh.
+ */
+export function CreateTiledNavMeshConfig(parameters: INavMeshParametersV2): Partial<any>;
+/**
+ * Creates a TileCacheNavMesh configuration based on the provided parameters.
+ * @param parameters The parameters used to configure the TileCacheNavMesh generation.
+ * @returns A configuration object for generating a TileCacheNavMesh.
+ */
+export function CreateTileCacheNavMeshConfig(parameters: INavMeshParametersV2): Partial<any>;
+/**
+ * Convert IAgentParameters to Recast any
+ * @param config Agent parameters
+ * @returns Recast crowd agent paramaters
+ */
+export function ToSoloNavMeshGeneratorConfig(config: INavMeshParametersV2): Partial<any>;
+/**
+ * Convert IAgentParameters to Recast any
+ * @param agentParams Agent parameters
+ * @returns Recast crowd agent paramaters
+ */
+export function ToCrowdAgentParams(agentParams: IAgentParametersV2): Partial<any>;
+
+}
+declare module "babylonjs-addons/msdfText/textRenderer" {
+import { AbstractEngine } from "babylonjs/Engines/abstractEngine";
+import { IDisposable } from "babylonjs/scene";
+import { Nullable } from "babylonjs/types";
+import { FontAsset } from "babylonjs-addons/msdfText/fontAsset";
+import { ParagraphOptions } from "babylonjs-addons/msdfText/paragraphOptions";
+import { IColor4Like, IMatrixLike } from "babylonjs/Maths/math.like";
+/**
+ * Abstract Node class from Babylon.js
+ */
+export interface INodeLike {
+    getWorldMatrix(): IMatrixLike;
+}
+/**
+ * Class used to render text using MSDF (Multi-channel Signed Distance Field) technique
+ * Thanks a lot to the work of Bhushan_Wagh and zb_sj for their amazing work on MSDF for Babylon.js
+ * #6RLCWP#16
+ * Star wars scroller: #6RLCWP#29
+ * With metrics: #6RLCWP#35
+ * Thickness: #IABMEZ#3
+ * Solar system: #9YCDYC#9
+ * Stroke: #6RLCWP#37
+ */
+export class TextRenderer implements IDisposable {
+    private readonly _useVAO;
+    private _engine;
+    private _shaderLanguage;
+    private _vertexBuffers;
+    private _spriteBuffer;
+    private _worldBuffer;
+    private _uvBuffer;
+    private _drawWrapperBase;
+    private _vertexArrayObject;
+    private _font;
+    private _charMatrices;
+    private _charUvs;
+    private _isDirty;
+    private _baseLine;
+    private _scalingMatrix;
+    private _fontScaleMatrix;
+    private _offsetMatrix;
+    private _translationMatrix;
+    private _baseMatrix;
+    private _scaledMatrix;
+    private _localMatrix;
+    private _finalMatrix;
+    private _lineMatrix;
+    private _parentWorldMatrix;
+    /**
+     * Gets or sets the color of the text
+     */
+    color: IColor4Like;
+    /**
+     * Gets or sets the color of the stroke around the text
+     */
+    strokeColor: IColor4Like;
+    /**
+     * Gets or sets the width of the stroke around the text (inset)
+     */
+    strokeInsetWidth: number;
+    /**
+     * Gets or sets the width of the stroke around the text (outset)
+     */
+    strokeOutsetWidth: number;
+    /**
+     * Gets or sets the thickness of the text (0 means as defined in the font)
+     * Value must be between -0.5 and 0.5
+     */
+    thicknessControl: number;
+    private _parent;
+    /**
+     * Gets or sets the parent of the text renderer
+     */
+    get parent(): Nullable<INodeLike>;
+    set parent(value: Nullable<INodeLike>);
+    private _transformMatrix;
+    /**
+     * Gets or sets the transform matrix of the text renderer
+     * It will be applied in that order:
+     * parent x transform x paragraph world
+     */
+    get transformMatrix(): IMatrixLike;
+    set transformMatrix(value: IMatrixLike);
+    /**
+     * Gets or sets if the text is billboarded
+     */
+    isBillboard: boolean;
+    /**
+     * Gets or sets if the text is screen projected
+     * This will work only if the text is billboarded
+     */
+    isBillboardScreenProjected: boolean;
+    /**
+     * Gets the number of characters in the text renderer
+     */
+    get characterCount(): number;
+    /**
+     * Gets or sets if the text renderer should ignore the depth buffer
+     * Default is false
+     */
+    ignoreDepthBuffer: boolean;
+    private constructor();
+    private _resizeBuffers;
+    private _setShaders;
+    /**
+     * Add a paragraph of text to the renderer
+     * @param text define the text to add
+     * @param options define the options to use for the paragraph (optional)
+     * @param worldMatrix define the world matrix to use for the paragraph (optional)
+     */
+    addParagraph(text: string, options?: Partial<ParagraphOptions>, worldMatrix?: IMatrixLike): void;
+    /**
+     * Render the text using the provided view and projection matrices
+     * @param viewMatrix define the view matrix to use
+     * @param projectionMatrix define the projection matrix to use
+     */
+    render(viewMatrix: IMatrixLike, projectionMatrix: IMatrixLike): void;
+    /**
+     * Release associated resources
+     */
+    dispose(): void;
+    /**
+     * Creates a new TextRenderer instance asynchronously
+     * @param font define the font asset to use
+     * @param engine define the engine to use
+     * @returns a promise that resolves to the created TextRenderer instance
+     */
+    static CreateTextRendererAsync(font: FontAsset, engine: AbstractEngine): Promise<TextRenderer>;
+}
+
+}
+declare module "babylonjs-addons/msdfText/paragraphOptions" {
+import { IVector2Like } from "babylonjs/Maths/math.like";
+import { SdfTextLine } from "babylonjs-addons/msdfText/sdf/line";
+import { SdfGlyph } from "babylonjs-addons/msdfText/sdf/glyph";
+export interface ISdfTextParagraphMetrics {
+    /** @internal */
+    readonly paragraph: string;
+    /** @internal */
+    readonly lines: SdfTextLine[];
+    /** @internal */
+    readonly width: number;
+    /** @internal */
+    readonly height: number;
+    /** @internal */
+    readonly glyphs: SdfGlyph[];
+}
+/** @internal */
+export type ParagraphOptions = {
+    maxWidth: number;
+    lineHeight: number;
+    letterSpacing: number;
+    tabSize: number;
+    whiteSpace: "pre-line";
+    textAlign: "left" | "right" | "center";
+    translate: IVector2Like | undefined;
+    customLayoutEngine?: (text: string, options: ParagraphOptions) => ISdfTextParagraphMetrics;
+};
+/** @internal */
+export const DefaultParagraphOptions: ParagraphOptions;
+
+}
+declare module "babylonjs-addons/msdfText/index" {
+export * from "babylonjs-addons/msdfText/fontAsset";
+export * from "babylonjs-addons/msdfText/paragraphOptions";
+export * from "babylonjs-addons/msdfText/textRenderer";
+export * from "babylonjs-addons/msdfText/sdf/index";
+export * from "babylonjs-addons/msdfText/shaders/msdf.vertex";
+export * from "babylonjs-addons/msdfText/shaders/msdf.fragment";
+export * from "babylonjs-addons/msdfText/shadersWGSL/msdf.vertex";
+export * from "babylonjs-addons/msdfText/shadersWGSL/msdf.fragment";
+
+}
+declare module "babylonjs-addons/msdfText/fontAsset" {
+import { IDisposable, Scene } from "babylonjs/scene";
+import { BMFontChar } from "babylonjs-addons/msdfText/sdf/bmFont";
+import { SdfFont } from "babylonjs-addons/msdfText/sdf/font";
+import { Texture } from "babylonjs/Materials/Textures/texture";
+/**
+ * Class representing a font asset for SDF (Signed Distance Field) rendering.
+ */
+export class FontAsset implements IDisposable {
+    private readonly _chars;
+    private readonly _charsRegex;
+    private readonly _kernings;
+    /** @internal */
+    readonly _font: SdfFont;
+    /**
+     * Gets the font scale value
+     */
+    readonly scale: number;
+    /**
+     * Gets the list of used textures
+     */
+    readonly textures: Texture[];
+    /**
+     * Creates a new FontAsset instance.
+     * @param definitionData defines the font data in JSON format.
+     * @param textureUrl defines the url of the texture to use for the font.
+     * @param scene defines the hosting scene.
+     */
+    constructor(definitionData: string, textureUrl: string, scene?: Scene);
+    dispose(): void;
+    private _updateFallbacks;
+    /** @internal */
+    _getChar(charCode: number): BMFontChar;
+    /** @internal */
+    _getKerning(first: number, second: number): number;
+    /** @internal */
+    _unsupportedChars(text: string): string;
+}
+
+}
+declare module "babylonjs-addons/msdfText/shadersWGSL/msdf.vertex" {
+/** @internal */
+export const msdfVertexShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/msdfText/shadersWGSL/msdf.fragment" {
+/** @internal */
+export const msdfPixelShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/msdfText/shaders/msdf.vertex" {
+/** @internal */
+export const msdfVertexShader: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/msdfText/shaders/msdf.fragment" {
+/** @internal */
+export const msdfPixelShader: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/msdfText/sdf/paragraph" {
+import { FontAsset } from "babylonjs-addons/msdfText/fontAsset";
+import { type ParagraphOptions } from "babylonjs-addons/msdfText/paragraphOptions";
+import { SdfGlyph } from "babylonjs-addons/msdfText/sdf/glyph";
+import { SdfTextLine } from "babylonjs-addons/msdfText/sdf/line";
+/** @internal */
+export class SdfTextParagraph {
+    readonly text: string;
+    readonly fontAsset: FontAsset;
+    readonly options: ParagraphOptions;
+    get lineHeight(): number;
+    readonly paragraph: string;
+    readonly lines: SdfTextLine[];
+    readonly width: number;
+    readonly height: number;
+    readonly glyphs: SdfGlyph[];
+    constructor(text: string, fontAsset: FontAsset, options?: Partial<ParagraphOptions>);
+    private _computeMetrics;
+    private _breakLines;
+    private _collapse;
+    private _wrap;
+}
+
+}
+declare module "babylonjs-addons/msdfText/sdf/line" {
+import { SdfGlyph } from "babylonjs-addons/msdfText/sdf/glyph";
+/** @internal */
+export type SdfTextLine = {
+    text: string;
+    glyphs: SdfGlyph[];
+    start: number;
+    end: number;
+    width: number;
+};
 
 }
 declare module "babylonjs-addons/msdfText/sdf/index" {
@@ -1631,379 +3059,1692 @@ export class Atmosphere implements IDisposable {
     get isAerialPerspectiveLutEnabled(): boolean;
     set isAerialPerspectiveLutEnabled(value: boolean);
     /**
-     * Gets the aerial perspective LUT render target or null if not enabled.
-     * @returns The render target.
+     * Gets the aerial perspective LUT render target or null if not enabled.
+     * @returns The render target.
+     */
+    get aerialPerspectiveLutRenderTarget(): Nullable<RenderTargetTexture>;
+    /**
+     * The intensity of the aerial perspective.
+     */
+    get aerialPerspectiveIntensity(): number;
+    set aerialPerspectiveIntensity(value: number);
+    /**
+     * The amount of light transmitted into aerial perspective.
+     * A scale of 1 is physically correct.
+     */
+    get aerialPerspectiveTransmittanceScale(): number;
+    set aerialPerspectiveTransmittanceScale(value: number);
+    /**
+     * The amount of saturation applied to the aerial perspective.
+     * Reducing to zero desaturates the aerial perspective completely.
+     * A value of 1 has no effect.
+     */
+    get aerialPerspectiveSaturation(): number;
+    set aerialPerspectiveSaturation(value: number);
+    /**
+     * A radiance bias applied to aerial perspective.
+     */
+    get aerialPerspectiveRadianceBias(): number;
+    set aerialPerspectiveRadianceBias(value: number);
+    /**
+     * True if the composition should be in linear space (e.g. for HDR rendering).
+     * Typically linear space is expected when ImageProcessing is enabled via PostProcesses.
+     * False for non-linear output.
+     */
+    get isLinearSpaceComposition(): boolean;
+    set isLinearSpaceComposition(value: boolean);
+    /**
+     * True if the {@link light} value should be specified in linear space.
+     * If using PBRMaterials, light value is expected to be linear.
+     */
+    get isLinearSpaceLight(): boolean;
+    set isLinearSpaceLight(value: boolean);
+    /**
+     * The lookup table for transmittance.
+     */
+    get transmittanceLut(): Nullable<TransmittanceLut>;
+    /**
+     * Gets the multiple scattering LUT render target.
+     * @returns The render target.
+     */
+    get multiScatteringLutRenderTarget(): Nullable<RenderTargetTexture>;
+    /**
+     * The lookup table for diffuse sky irradiance, or null if not enabled.
+     */
+    get diffuseSkyIrradianceLut(): Nullable<DiffuseSkyIrradianceLut>;
+    /**
+     * The properties used to describe the size and optical parameters of the atmosphere.
+     */
+    get physicalProperties(): AtmospherePhysicalProperties;
+    /**
+     * The height in kilometers of the scene's origin.
+     */
+    get originHeight(): number;
+    set originHeight(value: number);
+    /**
+     * When atmospheric scattering is applied to surfaces, if this value is set to true,
+     * a grayscale approximation of the transmittance is used to dim surfaces.
+     *
+     * When set to false, the atmospheric composition does not dim the surfaces behind it.
+     * It is up to the client application to apply transmittance manually.
+     */
+    get applyApproximateTransmittance(): boolean;
+    set applyApproximateTransmittance(value: boolean);
+    /**
+     * The directional lights in the scene which represent the suns illuminating the atmosphere.
+     * Each frame, the color and intensity of the lights are updated based on the camera position and the light's direction.
+     */
+    get lights(): ReadonlyArray<DirectionalLight>;
+    /**
+     * The rendering group ID for the sky compositor.
+     * The sky will only be rendered for this group.
+     */
+    get skyRenderingGroup(): number;
+    set skyRenderingGroup(value: number);
+    /**
+     * The rendering group ID for the aerial perspective compositor.
+     * Aerial perspective will only be rendered for this group.
+     */
+    get aerialPerspectiveRenderingGroup(): number;
+    set aerialPerspectiveRenderingGroup(value: number);
+    /**
+     * The rendering group ID for the globe atmosphere compositor.
+     * The globe atmosphere will only be rendered for this group.
+     */
+    get globeAtmosphereRenderingGroup(): number;
+    set globeAtmosphereRenderingGroup(value: number);
+    /**
+     * Gets the uniform buffer used to store the atmosphere's physical properties.
+     */
+    get uniformBuffer(): UniformBuffer;
+    /**
+     * Gets the camera-related variables for this atmosphere. Updated each frame.
+     */
+    get cameraAtmosphereVariables(): AtmospherePerCameraVariables;
+    readonly uniqueId: number;
+    /**
+     * Constructs the {@link Atmosphere}.
+     * @param name - The name of this instance.
+     * @param scene - The scene to which the atmosphere will be added.
+     * @param lights - The light sources that illuminate the atmosphere. Currently only supports one light, and that light should be the first light in the scene.
+     * @param options - The options used to create the atmosphere.
+     */
+    constructor(name: string, scene: Scene, lights: DirectionalLight[], options?: IAtmosphereOptions);
+    /**
+     * @override
+     */
+    dispose(): void;
+    /**
+     * True if the atmosphere is enabled.
+     * @returns - True if the atmosphere is enabled.
+     */
+    isEnabled(): boolean;
+    /**
+     * Sets the enabled state of the atmosphere.
+     * @param enabled - True to enable the atmosphere, false to disable it.
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * The class name of the {@link Atmosphere}.
+     * @returns - The class name of the atmosphere.
+     */
+    getClassName(): string;
+    /**
+     * Gets the color of a light after being transmitted through the atmosphere to a point specified by its distance to the planet center and its geocentric normal.
+     * NOTE, the result is always a linear space color.
+     * @param directionToLight - The direction of the light.
+     * @param pointRadius - The distance from the planet center to the point in kilometers.
+     * @param pointGeocentricNormal - The geocentric normal at the point i.e., normalize(point - planet center).
+     * @param result - The color to store the result in.
+     * @returns The result color.
+     */
+    getTransmittedColorToRef: <T extends IColor3Like>(directionToLight: IVector3Like, pointRadius: number, pointGeocentricNormal: IVector3Like, result: T) => T;
+    /**
+     * Gets the diffuse sky irradiance. Result is always in linear space.
+     * @param directionToLight - The direction of the point to the light.
+     * @param pointRadius - The distance from the planet center to the point in kilometers.
+     * @param pointGeocentricNormal - The geocentric normal at the point: normalize(point - planet center).
+     * @param lightIrradiance - The irradiance of the light.
+     * @param result - The color to store the result in.
+     * @returns The result color.
+     */
+    getDiffuseSkyIrradianceToRef: <T extends IColor3Like>(directionToLight: IVector3Like, pointRadius: number, pointGeocentricNormal: IVector3Like, lightIrradiance: number, result: T) => T;
+    /**
+     * Creates a new {@link EffectWrapper} for the multiple scattering LUT
+     * @returns The newly created {@link EffectWrapper}.
+     */
+    private _createMultiScatteringEffectWrapper;
+    /**
+     * Draws the multiple scattering LUT using {@link EffectWrapper} and {@link EffectRenderer}.
+     */
+    private _drawMultiScatteringLut;
+    /**
+     * Draws the aerial perspective compositor using {@link EffectWrapper} and {@link EffectRenderer}.
+     */
+    drawAerialPerspectiveCompositor(): void;
+    /**
+     * Draws the sky compositor using {@link EffectWrapper} and {@link EffectRenderer}.
+     */
+    drawSkyCompositor(): void;
+    /**
+     * Draws the globe atmosphere compositor using {@link EffectWrapper} and {@link EffectRenderer}.
+     */
+    drawGlobeAtmosphereCompositor(): void;
+    private _disposeSkyCompositor;
+    private _disposeAerialPerspectiveCompositor;
+    private _disposeGlobeAtmosphereCompositor;
+    /**
+     * Updates the camera variables that are specific to the atmosphere.
+     * @param camera - The camera to update the variables for.
+     */
+    private _updatePerCameraVariables;
+    /**
+     * Renders the lookup tables, some of which can vary per-camera.
+     * It is expected that updatePerCameraVariables was previously called.
+     */
+    private _renderLutsForCamera;
+    /**
+     * Renders the lookup tables that do not depend on a camera position.
+     */
+    renderGlobalLuts(): void;
+    /**
+     * Binds the atmosphere's uniform buffer to an {@link Effect}.
+     * @param effect - The {@link Effect} to bind the uniform buffer to.
+     */
+    bindUniformBufferToEffect(effect: Effect): void;
+    /**
+     * Updates the atmosphere's uniform buffer.
+     */
+    updateUniformBuffer(): void;
+    /**
+     * Draws the aerial perspective LUT using {@link EffectWrapper} and {@link EffectRenderer}.
+     */
+    private _drawAerialPerspectiveLut;
+    /**
+     * Draws the sky view LUT using {@link EffectWrapper} and {@link EffectRenderer}.
+     */
+    private _drawSkyViewLut;
+}
+
+}
+declare module "babylonjs-addons/atmosphere/test/unit/sampling.test" {
+export {};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/transmittance.fragment" {
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
+import "babylonjs/Shaders/ShadersInclude/helperFunctions";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions";
+/** @internal */
+export const transmittancePixelShader: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/skyView.fragment" {
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
+import "babylonjs/Shaders/ShadersInclude/helperFunctions";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions";
+/** @internal */
+export const skyViewPixelShader: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/multiScattering.fragment" {
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
+import "babylonjs/Shaders/ShadersInclude/helperFunctions";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions";
+/** @internal */
+export const multiScatteringPixelShader: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/fullscreenTriangle.vertex" {
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
+/** @internal */
+export const fullscreenTriangleVertexShader: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/diffuseSkyIrradiance.fragment" {
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
+import "babylonjs/Shaders/ShadersInclude/helperFunctions";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/depthFunctions";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions";
+import "babylonjs/Shaders/ShadersInclude/importanceSampling";
+import "babylonjs/Shaders/ShadersInclude/pbrBRDFFunctions";
+import "babylonjs/Shaders/ShadersInclude/hdrFilteringFunctions";
+/** @internal */
+export const diffuseSkyIrradiancePixelShader: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/compositeSky.fragment" {
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
+import "babylonjs/Shaders/ShadersInclude/helperFunctions";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/depthFunctions";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions";
+/** @internal */
+export const compositeSkyPixelShader: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/compositeGlobeAtmosphere.fragment" {
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
+import "babylonjs/Shaders/ShadersInclude/helperFunctions";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/depthFunctions";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions";
+/** @internal */
+export const compositeGlobeAtmospherePixelShader: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/compositeAerialPerspective.fragment" {
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
+import "babylonjs/Shaders/ShadersInclude/helperFunctions";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/depthFunctions";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions";
+/** @internal */
+export const compositeAerialPerspectivePixelShader: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/aerialPerspective.fragment" {
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
+import "babylonjs/Shaders/ShadersInclude/helperFunctions";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions";
+/** @internal */
+export const aerialPerspectivePixelShader: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/ShadersInclude/depthFunctions" {
+/** @internal */
+export const depthFunctions: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereVertexDeclaration" {
+/** @internal */
+export const atmosphereVertexDeclaration: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration" {
+/** @internal */
+export const atmosphereUboDeclaration: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions" {
+import "babylonjs/Shaders/ShadersInclude/intersectionFunctions";
+/** @internal */
+export const atmosphereFunctions: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration" {
+/** @internal */
+export const atmosphereFragmentDeclaration: {
+    name: string;
+    shader: string;
+};
+
+}
+
+declare module "babylonjs-addons" {
+    export * from "babylonjs-addons/index";
+}
+
+
+declare module ADDONS {
+
+
+    /**
+     * Recast injection type
      */
-    get aerialPerspectiveLutRenderTarget(): Nullable<RenderTargetTexture>;
+    export type RecastInjection = any;
     /**
-     * The intensity of the aerial perspective.
+     * Off-mesh connection data
      */
-    get aerialPerspectiveIntensity(): number;
-    set aerialPerspectiveIntensity(value: number);
+    export interface IOffMeshConnection {
+        /**
+         * The start position of the off-mesh connection.
+         */
+        startPosition: BABYLON.IVector3Like;
+        /**
+         * The end position of the off-mesh connection.
+         */
+        endPosition: BABYLON.IVector3Like;
+        /**
+         * The radius of the off-mesh connection.
+         */
+        radius: number;
+        /**
+         * The type of the off-mesh connection.
+         */
+        bidirectional: boolean;
+        /**
+         * The area type of the off-mesh connection.
+         */
+        area: number;
+        /**
+         * The flags of the off-mesh connection.
+         */
+        flags: number;
+        /**
+         * The user ID of the off-mesh connection.
+         * @remarks This can be used to associate the off-mesh connection with a specific user
+         */
+        userId?: number;
+    }
     /**
-     * The amount of light transmitted into aerial perspective.
-     * A scale of 1 is physically correct.
+     * Result of a navigation mesh creation.
      */
-    get aerialPerspectiveTransmittanceScale(): number;
-    set aerialPerspectiveTransmittanceScale(value: number);
+    export type CreateNavMeshResult = BABYLON.Nullable<{
+        /**
+         * Navigation mesh
+         */
+        navMesh: any;
+        /**
+         * Navigation mesh query
+         */
+        navMeshQuery: any;
+        /**
+         * Intermediates generated during the any creation process.
+         * @remarks This is only available if the `keepIntermediates` parameter is set to true in the `INavMeshParametersV2`.
+         * It can be used for debugging or visualization purposes.
+         */
+        intermediates?: GeneratorIntermediates;
+        /**
+         * Tile cache generated during the any creation process.
+         * @remarks This is only available if the `maxObstacles` parameter is set to a value greater than 0 in the `INavMeshParametersV2`. Defaults `maxObstacles` to 128.
+         * It can be used for obstacle avoidance and dynamic navigation mesh updates.
+         * @see {@link INavMeshParametersV2}
+         */
+        tileCache?: any;
+    }>;
     /**
-     * The amount of saturation applied to the aerial perspective.
-     * Reducing to zero desaturates the aerial perspective completely.
-     * A value of 1 has no effect.
+     * Agent parameters
+     * For actual limits and default values check the recast-navigation-js docs.
+     * @see https://docs.recast-navigation-js.isaacmason.com/types/index.CrowdAgentParams.html
      */
-    get aerialPerspectiveSaturation(): number;
-    set aerialPerspectiveSaturation(value: number);
+    export interface IAgentParametersV2 extends BABYLON.IAgentParameters {
+        /**
+         * Flags that impact steering behavior.
+         */
+        updateFlags: number;
+        /**
+         * The index of the avoidance configuration to use for the agent. [Limits: 0 to #DT_CROWD_MAX_OBSTAVOIDANCE_PARAMS inclusive]
+         */
+        obstacleAvoidanceType: number;
+        /**
+         * The index of the query filter used by this agent.
+         */
+        queryFilterType: number;
+        /**
+         * User defined data attached to the agent.
+         */
+        userData: unknown;
+    }
     /**
-     * A radiance bias applied to aerial perspective.
+     * any parameters
+     * For actual limits and default values check the recast-navigation-js docs.
+     * @see https://docs.recast-navigation-js.isaacmason.com/types/index.RecastConfig.html
      */
-    get aerialPerspectiveRadianceBias(): number;
-    set aerialPerspectiveRadianceBias(value: number);
+    export interface INavMeshParametersV2 extends BABYLON.INavMeshParameters {
+        /**
+         * OffMeshConnections - Teleports
+         */
+        offMeshConnections?: IOffMeshConnection[];
+        /**
+         * Whether to keep intermediate navigation mesh data for debug visualization. Default is false.
+         */
+        keepIntermediates?: boolean;
+        /**
+         * The maximum number of obstacles that can be added to the navigation mesh. Default is 32.
+         * If this value is greater then 0, the navigation mesh will be generated with a tile cache.
+         */
+        maxObstacles?: number;
+        /**
+         * The size of each tile in the tiled navigation mesh. Default is 32.
+         */
+        expectedLayersPerTile?: number;
+        /**
+         * Function which is sets the polyAreas and polyFlags for the tile cache mesh. Defaults to a function that sets all areas to 0 and flags to 1.
+         */
+        tileCacheMeshProcess?: any;
+    }
     /**
-     * True if the composition should be in linear space (e.g. for HDR rendering).
-     * Typically linear space is expected when ImageProcessing is enabled via PostProcesses.
-     * False for non-linear output.
+     * Result of a steer target computation.
      */
-    get isLinearSpaceComposition(): boolean;
-    set isLinearSpaceComposition(value: boolean);
+    export type SteerTargetResult = {
+        /**
+         * Indicates whether the steering target computation was successful.
+         */
+        success: false;
+    } | {
+        /**
+         * Indicates whether the steering target computation was successful.
+         */
+        success: true;
+        /**
+         * The position to steer towards.
+         */
+        steerPos: BABYLON.Vector3;
+        /**
+         * The flag indicating the type of steering position.
+         */
+        steerPosFlag: number;
+        /**
+         * The reference to the polygon that the steering position is associated with.
+         */
+        steerPosRef: number;
+        /**
+         * The points that make up the path to the steering position.
+         */
+        points: BABYLON.Vector3[];
+    };
     /**
-     * True if the {@link light} value should be specified in linear space.
-     * If using PBRMaterials, light value is expected to be linear.
+     * Error types for path computation.
      */
-    get isLinearSpaceLight(): boolean;
-    set isLinearSpaceLight(value: boolean);
+    export var ComputePathError: {
+        START_NEAREST_POLY_FAILED: string;
+        END_NEAREST_POLY_FAILED: string;
+        FIND_PATH_FAILED: string;
+        NO_POLYGON_PATH_FOUND: string;
+        NO_CLOSEST_POINT_ON_LAST_POLYGON_FOUND: string;
+    };
+    export type ComputePathErrorType = (typeof ComputePathError)[keyof typeof ComputePathError];
     /**
-     * The lookup table for transmittance.
+     * Result of a path computation.
      */
-    get transmittanceLut(): Nullable<TransmittanceLut>;
+    export type ComputePathResult = {
+        /**
+         * Indicates whether the path computation was successful.
+         */
+        success: boolean;
+        /**
+         * The error message if the path computation failed.
+         */
+        error?: {
+            /**
+             * A descriptive error message.
+             */
+            name?: string;
+            /**
+             * The type of error that occurred during path computation.
+             * @remarks This will be one of the values from `ComputePathError`
+             */
+            type?: ComputePathErrorType;
+            /**
+             * Statusring describing the error.
+             */
+            status?: number;
+        };
+        /**
+         * The computed path as an array of BABYLON.Vector3 points.
+         */
+        path: BABYLON.IVector3Like[];
+    };
     /**
-     * Gets the multiple scattering LUT render target.
-     * @returns The render target.
+     * Intermediates generated during the any creation process.
+     * @remarks This is only available if the `keepIntermediates` parameter is set to true in the `INavMeshParametersV2`.
+     * It can be used for debugging or visualization purposes.
      */
-    get multiScatteringLutRenderTarget(): Nullable<RenderTargetTexture>;
+    export type GeneratorIntermediates = any | any | any | null;
+
+
+
+
     /**
-     * The lookup table for diffuse sky irradiance, or null if not enabled.
+     * Generates a navigation mesh in a web worker.
      */
-    get diffuseSkyIrradianceLut(): Nullable<DiffuseSkyIrradianceLut>;
+    export function GenerateNavMeshWorker(): void;
+
+
+
+
     /**
-     * The properties used to describe the size and optical parameters of the atmosphere.
+     * Navigation plugin for Babylon.js. It is a simple wrapper around the recast-navigation-js library. Not all features are implemented.
+     * @remarks This plugin provides navigation mesh generation and pathfinding capabilities using the recast-navigation-js library
+     * @remarks It supports both single-threaded and multi-threaded generation of navigation meshes.
+     * @remarks The plugin can be used to create navigation meshes from meshes in a scene, compute paths, and manage crowd agents, etc.
+     * @remarks It also provides methods for creating obstacles and querying the navigation mesh.
+     * @see https://github.com/isaac-mason/recast-navigation-js
      */
-    get physicalProperties(): AtmospherePhysicalProperties;
+    export class RecastNavigationJSPluginV2 implements BABYLON.INavigationEnginePlugin {
+        /**
+         *  Creates a navigation mesh - will be injected by the factory
+         * @param meshes array of all the geometry used to compute the navigation mesh
+         * @param parameters bunch of parameters used to filter geometry
+         * @returns the created navmesh and navmesh query
+         */
+        createNavMeshImpl: (meshes: Array<BABYLON.Mesh>, parameters: INavMeshParametersV2) => CreateNavMeshResult;
+        /**
+         * Creates a navigation mesh - will be injected by the factory
+         * @param meshes array of all the geometry used to compute the navigation mesh
+         * @param parameters bunch of parameters used to filter geometry
+         * @returns the created navmesh and navmesh query
+         */
+        createNavMeshAsyncImpl: (meshes: Array<BABYLON.Mesh>, parameters: INavMeshParametersV2) => Promise<CreateNavMeshResult>;
+        /**
+         * recast-navigation-js injection
+         */
+        bjsRECAST: RecastInjection;
+        /**
+         * plugin name
+         */
+        name: string;
+        /**
+         * the navmesh created
+         */
+        navMesh?: any;
+        /**
+         * The navmesh query created from the navmesh
+         * @remarks This is used to query the navmesh for pathfinding and other navigation tasks
+         */
+        get navMeshQuery(): any;
+        private _navMeshQuery;
+        /**
+         * Intermediates generated during the navmesh creation
+         * @remarks This is used for debugging and visualization purposes.
+         * @remarks You have access to vertices, indices and vertex colors to visusalize the navmesh creation process.
+         * @remarks This is only available if the `keepIntermediates` parameter is set
+         * @remarks to true during navmesh generation.
+         */
+        private _intermediates?;
+        /**
+         * Gets the intermediates generated during the navmesh creation
+         * @returns The generator intermediates, or undefined if not available
+         */
+        get intermediates(): GeneratorIntermediates | undefined;
+        /**
+         * Tile cache used for tiled navigation meshes
+         * @remarks This is used to store and manage tiles of the navigation mesh for efficient path and when obstacles are used.
+         */
+        private _tileCache?;
+        /**
+         * Gets the tile cache used for tiled navigation meshes
+         * @returns The tile cache instance, or undefined if not available
+         */
+        get tileCache(): any | undefined;
+        private _maximumSubStepCount;
+        private _timeStep;
+        private _timeFactor;
+        private _crowd?;
+        /**
+         * Creates a RecastNavigationJSPluginV2 instance
+         * @param recastInjection The recast-navigation-js injection containing core and generators
+         */
+        constructor(recastInjection?: RecastInjection);
+        /**
+         * Set the time step of the navigation tick update.
+         * Default is 1/60.
+         * A value of 0 will disable fixed time update
+         * @param newTimeStep the new timestep to apply to this world.
+         */
+        setTimeStep(newTimeStep?: number): void;
+        /**
+         * Get the time step of the navigation tick update.
+         * @returns the current time step
+         */
+        getTimeStep(): number;
+        /**
+         * If delta time in navigation tick update is greater than the time step
+         * a number of sub iterations are done. If more iterations are need to reach deltatime
+         * they will be discarded.
+         * A value of 0 will set to no maximum and update will use as many substeps as needed
+         * @param newStepCount the maximum number of iterations
+         */
+        setMaximumSubStepCount(newStepCount?: number): void;
+        /**
+         * Get the maximum number of iterations per navigation tick update
+         * @returns the maximum number of iterations
+         */
+        getMaximumSubStepCount(): number;
+        /**
+         * Time factor applied when updating crowd agents (default 1). A value of 0 will pause crowd updates.
+         * @param value the time factor applied at update
+         */
+        set timeFactor(value: number);
+        /**
+         * Get the time factor used for crowd agent update
+         * @returns the time factor
+         */
+        get timeFactor(): number;
+        /**
+         * Creates a navigation mesh - will be injected by the factory
+         * @param meshes array of all the geometry used to compute the navigation mesh
+         * @param parameters bunch of parameters used to filter geometry
+         * @returns the created navmesh and navmesh query
+         * @throws Error if the function is not injected yet or if the navmesh is not created
+         */
+        createNavMesh(meshes: Array<BABYLON.Mesh>, parameters: INavMeshParametersV2): CreateNavMeshResult;
+        /**
+         * Creates a navigation mesh asynchronously - will be injected by the factory
+         * @param meshes array of all the geometry used to compute the navigation mesh
+         * @param parameters bunch of parameters used to filter geometry
+         * @returns the created navmesh and navmesh query
+         * @throws Error if the function is not injected yet or if the navmesh is not created
+         */
+        createNavMeshAsync(meshes: Array<BABYLON.Mesh>, parameters: INavMeshParametersV2): Promise<CreateNavMeshResult>;
+        /**
+         * Create a navigation mesh debug mesh
+         * @param scene is where the mesh will be added
+         * @returns debug display mesh
+         */
+        createDebugNavMesh(scene: BABYLON.Scene): BABYLON.Mesh;
+        /**
+         * Get a navigation mesh constrained position, closest to the parameter position
+         * @param position world position
+         * @returns the closest point to position constrained by the navigation mesh
+         */
+        getClosestPoint(position: BABYLON.IVector3Like, options?: {
+            /**
+             * The polygon filter to apply to the query.
+             */
+            filter?: any;
+            /**
+             * Half extents for the search box
+             */
+            halfExtents?: BABYLON.IVector3Like;
+        }): BABYLON.Vector3;
+        /**
+         * Get a navigation mesh constrained position, closest to the parameter position
+         * @param position world position
+         * @param result output the closest point to position constrained by the navigation mesh
+         */
+        getClosestPointToRef(position: BABYLON.IVector3Like, result: BABYLON.Vector3, options?: {
+            /**
+             * The polygon filter to apply to the query.
+             */
+            filter?: any;
+            /**
+             * Half extents for the search box
+             */
+            halfExtents?: BABYLON.IVector3Like;
+        }): void;
+        /**
+         * Get a navigation mesh constrained position, within a particular radius
+         * @param position world position
+         * @param maxRadius the maximum distance to the constrained world position
+         * @returns the closest point to position constrained by the navigation mesh
+         */
+        getRandomPointAround(position: BABYLON.IVector3Like, maxRadius: number, options?: {
+            startRef?: number;
+            /**
+             * The polygon filter to apply to the query.
+             */
+            filter?: any;
+            /**
+             * Half extents for the search box
+             */
+            halfExtents?: BABYLON.IVector3Like;
+        }): BABYLON.Vector3;
+        /**
+         * Get a navigation mesh constrained position, within a particular radius
+         * @param position world position
+         * @param maxRadius the maximum distance to the constrained world position
+         * @param result output the closest point to position constrained by the navigation mesh
+         */
+        getRandomPointAroundToRef(position: BABYLON.IVector3Like, maxRadius: number, result: BABYLON.Vector3, options?: {
+            startRef?: number;
+            /**
+             * The polygon filter to apply to the query.
+             */
+            filter?: any;
+            /**
+             * Half extents for the search box
+             */
+            halfExtents?: BABYLON.IVector3Like;
+        }): void;
+        /**
+         * Compute the final position from a segment made of destination-position
+         * @param position position to start from
+         * @param destination position to go to
+         * @param startRef the reference id of the start polygon
+         * @param options options for the function
+         * @returns the resulting point along the navmesh
+         */
+        moveAlong(position: BABYLON.IVector3Like, destination: BABYLON.IVector3Like, startRef?: number, options?: {
+            /**
+             * The polygon filter to apply to the query.
+             */
+            filter?: any;
+            /**
+             * The maximum number of polygons the output visited array can hold.
+             */
+            maxVisitedSize?: number;
+        }): BABYLON.Vector3;
+        /**
+         * Compute the final position from a segment made of destination-position
+         * @param position world position
+         * @param destination world position
+         * @param result output the resulting point along the navmesh
+         * @param startRef the reference id of the start polygon.
+         * @param options options for the function
+         */
+        moveAlongToRef(position: BABYLON.IVector3Like, destination: BABYLON.IVector3Like, result: BABYLON.Vector3, startRef?: number, options?: {
+            /**
+             * The polygon filter to apply to the query.
+             */
+            filter?: any;
+            maxVisitedSize?: number;
+        }): void;
+        /**
+         * Compute a navigation path from start to end. Returns an empty array if no path can be computed
+         * Path is straight.
+         * @param start world position
+         * @param end world position
+         * @param options options for the function
+         * @returns array containing world position composing the path
+         */
+        computePath(start: BABYLON.IVector3Like, end: BABYLON.IVector3Like, options?: {
+            /**
+             * The polygon filter to apply to the query.
+             */
+            filter?: any;
+            /**
+             * Half extents for the search box
+             */
+            halfExtents?: BABYLON.IVector3Like;
+            maxPathPolys?: number;
+            maxStraightPathPoints?: number;
+        }): BABYLON.Vector3[];
+        /**
+         * Creates a navigation mesh - will be injected by the factory
+         * @param start the start position of the navmesh
+         * @param end the end position of the navmesh
+         * @param options options to configure the path computation
+         * @returns array containing world position composing the path
+         */
+        computePathSmooth(start: BABYLON.Vector3, end: BABYLON.Vector3, options?: {
+            /**
+             * The polygon filter to apply to the query.
+             */
+            filter?: any;
+            /**
+             * Half extents for the search box
+             */
+            halfExtents?: BABYLON.IVector3Like;
+            maxPathPolys?: number;
+            maxSmoothPathPoints?: number;
+            stepSize?: number;
+            slop?: number;
+        }): BABYLON.Vector3[];
+        /**
+         * Create a new Crowd so you can add agents
+         * @param maxAgents the maximum agent count in the crowd
+         * @param maxAgentRadius the maximum radius an agent can have
+         * @param scene to attach the crowd to
+         * @returns the crowd you can add agents to
+         */
+        createCrowd(maxAgents: number, maxAgentRadius: number, scene: BABYLON.Scene): BABYLON.ICrowd;
+        /**
+         * Set the Bounding box extent for doing spatial queries (getClosestPoint, getRandomPointAround, ...)
+         * The queries will try to find a solution within those bounds
+         * default is (1,1,1)
+         * @param extent x,y,z value that define the extent around the queries point of reference
+         */
+        setDefaultQueryExtent(extent: BABYLON.IVector3Like): void;
+        /**
+         * Get the Bounding box extent specified by setDefaultQueryExtent
+         * @returns the box extent values
+         */
+        getDefaultQueryExtent(): BABYLON.Vector3;
+        /**
+         * Get the Bounding box extent result specified by setDefaultQueryExtent
+         * @param result output the box extent values
+         */
+        getDefaultQueryExtentToRef(result: BABYLON.Vector3): void;
+        /**
+         * build the navmesh from a previously saved state using getNavmeshData
+         * @param data the Uint8Array returned by getNavmeshData
+         */
+        buildFromNavmeshData(data: Uint8Array): void;
+        /**
+         * returns the navmesh data that can be used later. The navmesh must be built before retrieving the data
+         * @returns data the Uint8Array that can be saved and reused
+         */
+        getNavmeshData(): Uint8Array;
+        /**
+         * build the tile cache from a previously saved state using getTileCacheData
+         * @param tileCacheData the data returned by getTileCacheData
+         * @param tileCacheMeshProcess optional process to apply to each tile created
+         */
+        buildFromTileCacheData(tileCacheData: Uint8Array, tileCacheMeshProcess?: any): void;
+        /**
+         * returns the tile cache data that can be used later. The tile cache must be built before retrieving the data
+         * @returns the tile cache data that can be used later. The tile cache must be built before retrieving the data
+         * @throws Error if there is no any generated
+         * @remarks The returned data can be used to rebuild the tile cache later using buildFromTileCacheData
+         */
+        getTileCacheData(): Uint8Array;
+        /**
+         * Disposes
+         */
+        dispose(): void;
+        /**
+         * Creates a cylinder obstacle and add it to the navigation
+         * @param position world position
+         * @param radius cylinder radius
+         * @param height cylinder height
+         * @param doNotWaitForCacheUpdate if true the function will not wait for the tile cache to be fully updated before returning
+         * @returns the obstacle freshly created
+         */
+        addCylinderObstacle(position: BABYLON.IVector3Like, radius: number, height: number, doNotWaitForCacheUpdate?: boolean): BABYLON.Nullable<BABYLON.IObstacle>;
+        /**
+         * Creates an oriented box obstacle and add it to the navigation
+         * @param position world position
+         * @param extent box size
+         * @param angle angle in radians of the box orientation on Y axis
+         * @param doNotWaitForCacheUpdate if true the function will not wait for the tile cache to be fully updated before returning
+         * @returns the obstacle freshly created
+         */
+        addBoxObstacle(position: BABYLON.IVector3Like, extent: BABYLON.IVector3Like, angle: number, doNotWaitForCacheUpdate?: boolean): BABYLON.Nullable<BABYLON.IObstacle>;
+        /**
+         * Removes an obstacle created by addCylinderObstacle or addBoxObstacle
+         * @param obstacle obstacle to remove from the navigation
+         * @param doNotWaitForCacheUpdate if true the function will not wait for the tile cache to be fully updated before returning
+         *
+         */
+        removeObstacle(obstacle: BABYLON.IObstacle, doNotWaitForCacheUpdate?: boolean): void;
+        /**
+         * If this plugin is supported
+         * @returns true if plugin is supported
+         */
+        isSupported(): boolean;
+        /**
+         * Returns the seed used for randomized functions like `getRandomPointAround`
+         * @returns seed number
+         */
+        getRandomSeed(): number;
+        /**
+         * Set the seed used for randomized functions like `getRandomPointAround`
+         * @param seed number used as seed for random functions
+         */
+        setRandomSeed(seed: number): void;
+        /**
+         * Perform a raycast on the navmesh
+         * @param start start position
+         * @param end end position
+         * @returns if a direct path exists between start and end, and the hit point if any
+         */
+        raycast(start: BABYLON.IVector3Like, end: BABYLON.IVector3Like): {
+            hit: boolean;
+            hitPoint?: undefined;
+        } | {
+            hit: boolean;
+            hitPoint: BABYLON.Vector3;
+        };
+        /**
+         * Compute the final position from a segment made of destination-position, and return the height of the polygon
+         * This is a more sophisiticated version of moveAlong that will use the height of the polygon at the end position
+         * @param position world position to start from
+         * @param velocity wvelocity of the movement
+         * @param options options for the function
+         * @returns the resulting point along the navmesh, the polygon reference id and the height of the polygon
+         */
+        moveAlongWithVelocity(position: BABYLON.IVector3Like, velocity: BABYLON.IVector3Like, options?: {
+            /**
+             * The polygon filter to apply to the query.
+             */
+            filter?: any;
+            /**
+             * Half extents for the search box
+             */
+            halfExtents?: BABYLON.IVector3Like;
+            /**
+             * The maximum number of polygons the output visited array can hold.
+             */
+            maxVisitedSize?: number;
+        }): {
+            position: {
+                x: number;
+                y: number;
+                z: number;
+            };
+            polyRef: number;
+            height: number;
+        };
+        /**
+         * Handles common post-processing and validation of navmesh creation results
+         * @param result The partial result from navmesh creation
+         * @returns The validated and complete CreateNavMeshresult
+         */
+        private _processNavMeshResult;
+        private _preprocessParameters;
+    }
+
+
     /**
-     * The height in kilometers of the scene's origin.
+     * Recast Detour crowd implementation
+     * This class provides methods to manage a crowd of agents, allowing them to navigate a navigation mesh.
+     * It supports adding agents, updating their parameters, moving them to destinations, and checking their states.
+     * The crowd is updated in the scene's animation loop, and it notifies observers when agents reach their destinations.
      */
-    get originHeight(): number;
-    set originHeight(value: number);
+    export class RecastJSCrowd implements BABYLON.ICrowd {
+        /**
+         * Recast plugin
+         */
+        get navigationPlugin(): RecastNavigationJSPluginV2;
+        /**
+         * Link to the detour crowd
+         */
+        get recastCrowd(): any;
+        /**
+         * One transform per agent
+         */
+        get transforms(): BABYLON.TransformNode[];
+        /**
+         * All agents created
+         */
+        get agents(): readonly number[];
+        /**
+         * Agents reach radius
+         */
+        get reachRadii(): readonly number[];
+        private _navigationPlugin;
+        private _recastCrowd;
+        private _transforms;
+        private _agents;
+        private _reachRadii;
+        /**
+         * true when a destination is active for an agent and notifier hasn't been notified of reach
+         */
+        private _agentDestinationArmed;
+        /**
+         * agent current target
+         */
+        private _agentDestination;
+        /**
+         * Link to the scene is kept to unregister the crowd from the scene
+         */
+        private _scene;
+        private _engine;
+        /**
+         * Observer for crowd updates
+         */
+        private _onBeforeAnimationsObserver;
+        /**
+         * Fires each time an agent is in reach radius of its destination
+         */
+        onReachTargetObservable: BABYLON.Observable<{
+            /**
+             *
+             */
+            agentIndex: number;
+            /**
+             *
+             */
+            destination: BABYLON.Vector3;
+        }>;
+        /**
+         * Constructor
+         * @param plugin recastJS plugin
+         * @param maxAgents the maximum agent count in the crowd
+         * @param maxAgentRadius the maximum radius an agent can have
+         * @param scene to attach the crowd to
+         * @returns the crowd you can add agents to
+         */
+        constructor(plugin: RecastNavigationJSPluginV2, maxAgents: number, maxAgentRadius: number, scene: BABYLON.Scene);
+        /**
+         * Add a new agent to the crowd with the specified parameter a corresponding transformNode.
+         * You can attach anything to that node. The node position is updated in the scene update tick.
+         * @param pos world position that will be constrained by the navigation mesh
+         * @param parameters agent parameters
+         * @param transform hooked to the agent that will be update by the scene
+         * @returns agent index
+         */
+        addAgent(pos: BABYLON.IVector3Like, parameters: IAgentParametersV2, transform: BABYLON.TransformNode): number;
+        /**
+         * Returns the agent position in world space
+         * @param index agent index returned by addAgent
+         * @returns world space position
+         */
+        getAgentPosition(index: number): BABYLON.Vector3;
+        /**
+         * Returns the agent position result in world space
+         * @param index agent index returned by addAgent
+         * @param result output world space position
+         */
+        getAgentPositionToRef(index: number, result: BABYLON.Vector3): void;
+        /**
+         * Returns the agent velocity in world space
+         * @param index agent index returned by addAgent
+         * @returns world space velocity
+         */
+        getAgentVelocity(index: number): BABYLON.Vector3;
+        /**
+         * Returns the agent velocity result in world space
+         * @param index agent index returned by addAgent
+         * @param result output world space velocity
+         */
+        getAgentVelocityToRef(index: number, result: BABYLON.Vector3): void;
+        /**
+         * Returns the agent next target point on the path
+         * @param index agent index returned by addAgent
+         * @returns world space position
+         */
+        getAgentNextTargetPath(index: number): BABYLON.Vector3;
+        /**
+         * Returns the agent next target point on the path
+         * @param index agent index returned by addAgent
+         * @param result output world space position
+         */
+        getAgentNextTargetPathToRef(index: number, result: BABYLON.Vector3): void;
+        /**
+         * Gets the agent state
+         * @param index agent index returned by addAgent
+         * @returns agent state, 0 = DT_CROWDAGENT_STATE_INVALID, 1 = DT_CROWDAGENT_STATE_WALKING, 2 = DT_CROWDAGENT_STATE_OFFMESH
+         */
+        getAgentState(index: number): number;
+        /**
+         * returns true if the agent in over an off mesh link connection
+         * @param index agent index returned by addAgent
+         * @returns true if over an off mesh link connection
+         */
+        overOffmeshConnection(index: number): boolean;
+        /**
+         * Asks a particular agent to go to a destination. That destination is constrained by the navigation mesh
+         * @param index agent index returned by addAgent
+         * @param destination targeted world position
+         */
+        agentGoto(index: number, destination: BABYLON.IVector3Like): void;
+        /**
+         * Teleport the agent to a new position
+         * @param index agent index returned by addAgent
+         * @param destination targeted world position
+         */
+        agentTeleport(index: number, destination: BABYLON.IVector3Like): void;
+        /**
+         * Update agent parameters
+         * @param index agent index returned by addAgent
+         * @param parameters agent parameters
+         */
+        updateAgentParameters(index: number, parameters: IAgentParametersV2): void;
+        /**
+         * remove a particular agent previously created
+         * @param index agent index returned by addAgent
+         */
+        removeAgent(index: number): void;
+        /**
+         * get the list of all agents attached to this crowd
+         * @returns list of agent indices
+         */
+        getAgents(): number[];
+        /**
+         * Tick update done by the BABYLON.Scene. Agent position/velocity/acceleration is updated by this function
+         * @param deltaTime in seconds
+         */
+        update(deltaTime: number): void;
+        /**
+         * Set the Bounding box extent for doing spatial queries (getClosestPoint, getRandomPointAround, ...)
+         * The queries will try to find a solution within those bounds
+         * default is (1,1,1)
+         * @param extent x,y,z value that define the extent around the queries point of reference
+         */
+        setDefaultQueryExtent(extent: BABYLON.IVector3Like): void;
+        /**
+         * Get the Bounding box extent specified by setDefaultQueryExtent
+         * @returns the box extent values
+         */
+        getDefaultQueryExtent(): BABYLON.Vector3;
+        /**
+         * Get the Bounding box extent result specified by setDefaultQueryExtent
+         * @param result output the box extent values
+         */
+        getDefaultQueryExtentToRef(result: BABYLON.Vector3): void;
+        /**
+         * Get the next corner points composing the path (max 4 points)
+         * @param index agent index returned by addAgent
+         * @returns array containing world position composing the path
+         */
+        getCorners(index: number): BABYLON.Vector3[];
+        /**
+         * Release all resources
+         */
+        dispose(): void;
+    }
+
+
     /**
-     * When atmospheric scattering is applied to surfaces, if this value is set to true,
-     * a grayscale approximation of the transmittance is used to dim surfaces.
-     *
-     * When set to false, the atmospheric composition does not dim the surfaces behind it.
-     * It is up to the client application to apply transmittance manually.
+     * Injects the navigation mesh generation methods into the navigation plugin.
+     * @param navigationPlugin The navigation plugin to inject the methods into.
      */
-    get applyApproximateTransmittance(): boolean;
-    set applyApproximateTransmittance(value: boolean);
+    export function InjectGenerators(navigationPlugin: RecastNavigationJSPluginV2): void;
+
+
+
+
     /**
-     * The directional lights in the scene which represent the suns illuminating the atmosphere.
-     * Each frame, the color and intensity of the lights are updated based on the camera position and the light's direction.
+     * IMPORTANT!
+     * This file is still under construction and will change in the future.
+     * Workers are not yet supported.
+     * For more info visit: https://forum.babylonjs.com/t/replacing-recastjs-with-recast-navigation-js/56003/46
      */
-    get lights(): ReadonlyArray<DirectionalLight>;
     /**
-     * The rendering group ID for the sky compositor.
-     * The sky will only be rendered for this group.
+     * Builds a any and any from meshes using provided parameters.
+     * @param meshes The array of meshes used to create the any
+     * @param parameters The parameters used to configure the any generation.
+     * @param workerOptions Options for the worker, including a completion callback and the worker instance.
+     * @throws Error if the any data is invalid or cannot be deserialized.
      */
-    get skyRenderingGroup(): number;
-    set skyRenderingGroup(value: number);
+    export function GenerateNavMeshWithWorker(meshes: Array<BABYLON.Mesh>, parameters: INavMeshParametersV2, workerOptions: {
+        /**
+         * Completion callback that is called when the any generation is complete.
+         * @param navMesh The generated any
+         * @param navMeshQuery The any associated with the generated any
+         * @param tileCache Optional any if tile cache generation was used.
+         */
+        completion: (navMesh: any, navMeshQuery: any, tileCache?: any) => void;
+        /**
+         *  Worker instance used for asynchronous any generation.
+         */
+        worker: Worker;
+    }): void;
+
+
     /**
-     * The rendering group ID for the aerial perspective compositor.
-     * Aerial perspective will only be rendered for this group.
+     * Builds a NavMesh and NavMeshQuery from meshes using provided parameters.
+     * @param meshes The array of meshes used to create the NavMesh.
+     * @param parameters The parameters used to configure the NavMesh generation.
+     * @returns An object containing the NavMesh and NavMeshQuery.
+     * @remarks This function generates a NavMesh based on the provided meshes and parameters.
+     * It supports different configurations such as solo, tiled, and tile cache nav meshes.
+     * If you need obstacles, ensure that `maxObstacles` is set to a value greater than 0.
+     * Recommended values for `tileSize` are between 32 and 64 when using obstacles/tile cache.
+     * If you need a tiled nav mesh, ensure that `tileSize` is set to a value greater than 0.
+     * @throws Error if the NavMesh data is invalid or cannot be deserialized.
      */
-    get aerialPerspectiveRenderingGroup(): number;
-    set aerialPerspectiveRenderingGroup(value: number);
+    export function GenerateNavMesh(meshes: Array<BABYLON.Mesh>, parameters: INavMeshParametersV2): {
+        navMesh: any;
+        intermediates: any;
+        navMeshQuery: any;
+        tileCache: any;
+    };
+
+
     /**
-     * The rendering group ID for the globe atmosphere compositor.
-     * The globe atmosphere will only be rendered for this group.
+     *  Builds a NavMesh and NavMeshQuery from serialized data.
+     *  @param data The serialized NavMesh data.
+     *  @returns An object containing the NavMesh and NavMeshQuery.
+     *  @remarks This function deserializes the NavMesh data and creates a NavMeshQuery
+     *  instance for querying the NavMesh.
+     *  @throws Error if the NavMesh data is invalid or cannot be deserialized.
      */
-    get globeAtmosphereRenderingGroup(): number;
-    set globeAtmosphereRenderingGroup(value: number);
+    export function BuildFromNavmeshData(data: Uint8Array): {
+        navMesh: any;
+        navMeshQuery: any;
+        tileCache: undefined;
+    };
     /**
-     * Gets the uniform buffer used to store the atmosphere's physical properties.
+     * Builds a TileCache and NavMeshQuery from serialized data.
+     * @param data The serialized TileCache data.
+     * @param tileCacheMeshProcess Optional function to process the TileCache mesh.
+     * @returns An object containing the TileCache, NavMesh, and NavMeshQuery.
      */
-    get uniformBuffer(): UniformBuffer;
+    export function BuildFromTileCacheData(data: Uint8Array, tileCacheMeshProcess: any): {
+        navMesh: any;
+        navMeshQuery: any;
+        tileCache: any;
+    };
+
+
+
+
     /**
-     * Gets the camera-related variables for this atmosphere. Updated each frame.
+     * Creates a navigation plugin for the given scene using a worker.
+     * @returns A promise that resolves to the created navigation plugin.
+     * @remarks This function initializes the Recast module and sets up the navigation plugin to use a worker.
+     * The worker is used to handle the creation of the navigation mesh asynchronously.
+     * The `createNavMesh` method is not supported in worker mode, use `createNavMeshAsync` instead.
      */
-    get cameraAtmosphereVariables(): AtmospherePerCameraVariables;
-    readonly uniqueId: number;
+    export function CreateNavigationPluginWorkerAsync(): Promise<RecastNavigationJSPluginV2>;
+
+
     /**
-     * Constructs the {@link Atmosphere}.
-     * @param name - The name of this instance.
-     * @param scene - The scene to which the atmosphere will be added.
-     * @param lights - The light sources that illuminate the atmosphere. Currently only supports one light, and that light should be the first light in the scene.
-     * @param options - The options used to create the atmosphere.
+     * Creates a navigation plugin for the given scene.
+     * @returns A promise that resolves to the created navigation plugin.
+     * @remarks This function initializes the Recast module and sets up the navigation plugin.
      */
-    constructor(name: string, scene: Scene, lights: DirectionalLight[], options?: IAtmosphereOptions);
+    export function CreateNavigationPluginAsync(): Promise<RecastNavigationJSPluginV2>;
+
+
     /**
-     * @override
+     * Gets the RecastInjection instance (reference to the recast-navigation-js library).
+     * @returns The RecastInjection instance
+     * @throws Error if Recast is not initialized
      */
-    dispose(): void;
+    export function GetRecast(): RecastInjection;
     /**
-     * True if the atmosphere is enabled.
-     * @returns - True if the atmosphere is enabled.
+     * Sets the RecastInjection instance (reference to the recast-navigation-js library).
+     * @param recast The RecastInjection instance to set
      */
-    isEnabled(): boolean;
+    export function SetRecast(recast: RecastInjection): void;
     /**
-     * Sets the enabled state of the atmosphere.
-     * @param enabled - True to enable the atmosphere, false to disable it.
+     * Initialize the Manifold library
+     * @param version defines the version of the library to use, default is "0.43.0"
+     * @param options defines the options to use to initialize the library
      */
-    setEnabled(enabled: boolean): void;
+    export function InitRecast(version?: string, options?: {
+        instance: RecastInjection;
+    }): Promise<void>;
+
+
     /**
-     * The class name of the {@link Atmosphere}.
-     * @returns - The class name of the atmosphere.
+     * Creates a debug mesh for visualizing a any in the scene.
+     * @param navMesh The any to visualize.
+     * @param scene The scene in which to create the debug mesh.
+     * @param parent Optional parent node for the debug mesh.
+     * @param flags Poly flags to filter by, defaults to undefined to include all polys
+     * @returns The created debug mesh.
      */
-    getClassName(): string;
+    export function CreateDebugNavMesh(navMesh: any, scene: BABYLON.Scene, parent?: BABYLON.Node, flags?: number): BABYLON.Mesh;
+
+
+
+
+    export var DebugLayerOption: {
+        HEIGHTFIELD_SOLID: string;
+        HEIGHTFIELD_WALKABLE: string;
+        COMPACT_HEIGHTFIELD_SOLID: string;
+        COMPACT_HEIGHTFIELD_REGIONS: string;
+        COMPACT_HEIGHTFIELD_DISTANCE: string;
+        RAW_CONTOURS: string;
+        CONTOURS: string;
+        POLY_MESH: string;
+        POLY_MESH_DETAIL: string;
+        NAVMESH: string;
+        NAVMESH_BV_TREE: string;
+    };
+    export type DebugLayerOptions = (typeof DebugLayerOption)[keyof typeof DebugLayerOption];
     /**
-     * Gets the color of a light after being transmitted through the atmosphere to a point specified by its distance to the planet center and its geocentric normal.
-     * NOTE, the result is always a linear space color.
-     * @param directionToLight - The direction of the light.
-     * @param pointRadius - The distance from the planet center to the point in kilometers.
-     * @param pointGeocentricNormal - The geocentric normal at the point i.e., normalize(point - planet center).
-     * @param result - The color to store the result in.
-     * @returns The result color.
+     * NavigationDebugger is a utility class for visualizing navigation meshes and related data in a Babylon.js scene.
+     * It provides methods to draw various navigation-related primitives such as points, lines, triangles, and quads.
+     * It also supports drawing heightfields, compact heightfields, contours, poly meshes, and nav meshes.
      */
-    getTransmittedColorToRef: <T extends IColor3Like>(directionToLight: IVector3Like, pointRadius: number, pointGeocentricNormal: IVector3Like, result: T) => T;
+    export class NavigationDebugger {
+        private _scene;
+        /**
+         *  The name of the debug mesh used for navigation debugging.
+         *  This is used to group all navigation debug meshes under a single name for easier management
+         */
+        static NAV_MESH_DEBUG_NAME: string;
+        /**
+         * The name of the debug mesh used for visualization of the navigation mesh using points.
+         */
+        static NAV_MESH_DEBUG_NAME_POINTS: string;
+        /**
+         * The name of the debug mesh used for visualization of the navigation mesh using triangles.
+         */
+        static NAV_MESH_DEBUG_NAME_TRIS: string;
+        /**
+         * The name of the debug mesh used for visualization of the navigation mesh using quads.
+         */
+        static NAV_MESH_DEBUG_NAME_QUADS: string;
+        /**
+         * The name of the debug mesh used for visualization of the navigation mesh using lines.
+         */
+        static NAV_MESH_DEBUG_NAME_LINES: string;
+        /**
+         * The material used for rendering triangles in the navigation debug visualization.
+         */
+        triMaterial: BABYLON.StandardMaterial;
+        /**
+         * The material used for rendering points in the navigation debug visualization.
+         */
+        pointMaterial: BABYLON.StandardMaterial;
+        /**
+         * The list of line materials used in the navigation debug visualization.
+         */
+        lineMaterials: BABYLON.StandardMaterial[];
+        /**
+         * The parent node for the debug drawer.
+         */
+        debugDrawerParentNode: BABYLON.TransformNode;
+        /**
+         * * Gets or sets the primitive types to be drawn by the debug drawer.
+         * * This allows you to control which types of primitives (points, lines, tris, quads) are rendered in the navigation debug visualization.
+         * * The default value is `["points", "lines", "tris", "quads"]`.
+         * * You can modify this property to include or exclude specific primitive types based on your debugging needs.
+         * @returns An array of primitive types that the debug drawer will render.
+         */
+        get primitiveTypes(): any;
+        set primitiveTypes(value: any);
+        private _lineMaterialOptions;
+        private _pointMesh;
+        private _debugDrawerUtils;
+        private _primitiveTypes;
+        constructor(_scene: BABYLON.Scene, options?: {
+            parent?: {
+                node?: BABYLON.TransformNode | string;
+            };
+            primitiveTypes?: any;
+            materials?: {
+                triMaterial?: BABYLON.StandardMaterial;
+                pointMaterial?: BABYLON.StandardMaterial;
+                lineMaterialOptions: {
+                    greasedLineMaterialOptions: Partial<BABYLON.GreasedLineMaterialOptions>;
+                    greasedLineMeshOptions: Partial<BABYLON.GreasedLineMeshOptions>;
+                };
+            };
+        });
+        /**
+         * Resets the debug drawer by disposing of all child meshes in the debug drawer parent node.
+         * This is useful for clearing the debug visualization before drawing new primitives.
+         */
+        clear(): void;
+        /**
+         * Disposes of the debug drawer, including all meshes and materials used for rendering.
+         * This method should be called when the debug drawer is no longer needed to free up resources.
+         */
+        dispose(): void;
+        /**
+         * This method iterates through the provided primitives and draws them based on their type.
+         * It supports drawing points, lines, triangles, and quads, depending on the primitive type.
+         * @param primitives An array of debug drawer primitives to be drawn.
+         * @param options Optional parameters to control the drawing behavior, such as whether to join meshes.
+         */
+        drawPrimitives(primitives: any, options?: {
+            joinMeshes?: boolean;
+        }): void;
+        /**
+         * Draws a heightfield as solid using the debug drawer utilities.
+         * @param hf The heightfield to draw as solid.
+         */
+        drawHeightfieldSolid(hf: any): void;
+        /**
+         * Draws a heightfield as walkable using the debug drawer utilities.
+         * @param hf The heightfield to draw as walkable.
+         */
+        drawHeightfieldWalkable(hf: any): void;
+        /**
+         * Draws a compact heightfield as solid using the debug drawer utilities.
+         * @param chf The compact heightfield to draw as solid.
+         */
+        drawCompactHeightfieldSolid(chf: any): void;
+        /**
+         * Draws the regions of a compact heightfield using the debug drawer utilities.
+         * @param chf The compact heightfield to draw regions for.
+         */
+        drawCompactHeightfieldRegions(chf: any): void;
+        /**
+         * Draws the distance field of a compact heightfield using the debug drawer utilities.
+         * @param chf The compact heightfield to draw the distance for.
+         */
+        drawCompactHeightfieldDistance(chf: any): void;
+        /**
+         * Draws a heightfield layer using the debug drawer utilities.
+         * @param layer The heightfield layer to draw.
+         * @param idx The index of the layer to draw.
+         */
+        drawHeightfieldLayer(layer: any, idx: number): void;
+        /**
+         * Draws the layers of a heightfield using the debug drawer utilities.
+         * @param lset The heightfield layer set containing the layers to draw.
+         */
+        drawHeightfieldLayers(lset: any): void;
+        /**
+         * Draws the region connections of a any using the debug drawer utilities.
+         * @param cset any to draw
+         * @param alpha The alpha value for the drawn contours, default is 1.
+         */
+        drawRegionConnections(cset: any, alpha?: number): void;
+        /**
+         * Draws raw contours from a any using the debug drawer utilities.
+         * @param cset any to draw
+         * @param alpha The alpha value for the drawn contours, default is 1.
+         */
+        drawRawContours(cset: any, alpha?: number): void;
+        /**
+         * Draws contours from a any using the debug drawer utilities.
+         * @param cset any to draw
+         * @param alpha The alpha value for the drawn contours, default is 1.
+         */
+        drawContours(cset: any, alpha?: number): void;
+        /**
+         * Draws a poly mesh using the debug drawer utilities.
+         * @param mesh any to draw
+         */
+        drawPolyMesh(mesh: any): void;
+        /**
+         * Draws a poly mesh detail using the debug drawer utilities.
+         * @param dmesh any to draw
+         */
+        drawPolyMeshDetail(dmesh: any): void;
+        /**
+         * Draws a any using the debug drawer utilities.
+         * @param mesh any to draw
+         * @param flags Flags to control the drawing behavior, default is 0.
+         */
+        drawNavMesh(mesh: any, flags?: number): void;
+        /**
+         * Draws a any with closed list using the debug drawer utilities.
+         * @param mesh any to draw
+         * @param query any to use for drawing the closed list.
+         * @param flags Flags to control the drawing behavior, default is 0.
+         */
+        drawNavMeshWithClosedList(mesh: any, query: any, flags?: number): void;
+        /**
+         * Draws the nodes of a any using the debug drawer utilities.
+         * @param query any to use for drawing the nodes.
+         */
+        drawNavMeshNodes(query: any): void;
+        /**
+         * Draws the bounding volume tree of a any using the debug drawer utilities.
+         * @param mesh any to draw the bounding volume tree for.
+         */
+        drawNavMeshBVTree(mesh: any): void;
+        /**
+         * Draws the portals of a any using the debug drawer utilities.
+         * @param mesh any to draw the portals for.
+         */
+        drawNavMeshPortals(mesh: any): void;
+        /**
+         * Draws polygons of a any with specific flags using the debug drawer utilities.
+         * @param mesh any to draw the polygons with specific flags.
+         * @param flags The flags to filter the polygons to be drawn.
+         * @param col The color to use for the drawn polygons, represented as a number.
+         */
+        drawNavMeshPolysWithFlags(mesh: any, flags: number, col: number): void;
+        /**
+         * Draws polygons of a any with specific reference and color using the debug drawer utilities.
+         * @param mesh any to draw the polygons with specific reference and color.
+         * @param ref The reference number of the polygons to be drawn.
+         * @param col The color to use for the drawn polygons, represented as a number.
+         */
+        drawNavMeshPoly(mesh: any, ref: number, col: number): void;
+        /**
+         *  Get the intermediates from the generator
+         *  @param intermediates - The generator intermediates
+         *  @returns An object containing lists of heightfields, compact heightfields, contour sets
+         */
+        getIntermediates: (intermediates: GeneratorIntermediates) => {
+            heightfieldList: any;
+            compactHeightfieldList: any;
+            contourSetList: any;
+            polyMeshList: any;
+            polyMeshDetailList: any;
+        };
+        /**
+         *  Draw debug information based on the selected option
+         *  @param navMesh - The navigation mesh to draw
+         *  @param intermediates - The generator intermediates containing the data to draw
+         *  @param scene - The scene to draw in
+         *  @param option - The debug drawer option to use
+         *  @remarks This method will reset the debug drawer before drawing.
+         */
+        draw(navMesh: any, intermediates: GeneratorIntermediates, scene: BABYLON.Scene, option: DebugLayerOptions): void;
+        private _drawPoints;
+        private _drawLines;
+        private _drawTris;
+        private _drawQuads;
+        /**
+         * Merge the debug meshes for better performance
+         */
+        private _joinDebugMeshes;
+        private _convertUnindexedToIndexed;
+    }
+
+
     /**
-     * Gets the diffuse sky irradiance. Result is always in linear space.
-     * @param directionToLight - The direction of the point to the light.
-     * @param pointRadius - The distance from the planet center to the point in kilometers.
-     * @param pointGeocentricNormal - The geocentric normal at the point: normalize(point - planet center).
-     * @param lightIrradiance - The irradiance of the light.
-     * @param result - The color to store the result in.
-     * @returns The result color.
+     * Utility function based on Chaikin's alogrithm for navigation path smoothing and segment generation.
+     * @param points Array of points to be smoothed, where each point is an object with x, y, and z properties.
+     * @param iterations Number of smoothing iterations to apply. Default 1.
+     * @returns A new array of smoothed points after applying the Chaikin's algorithm.
      */
-    getDiffuseSkyIrradianceToRef: <T extends IColor3Like>(directionToLight: IVector3Like, pointRadius: number, pointGeocentricNormal: IVector3Like, lightIrradiance: number, result: T) => T;
+    export function GetChaikinSmoothPath(points: BABYLON.IVector3Like[], iterations?: number): BABYLON.IVector3Like[];
     /**
-     * Creates a new {@link EffectWrapper} for the multiple scattering LUT
-     * @returns The newly created {@link EffectWrapper}.
+     *  Generates a series of points that create an L-shaped path between each pair of points in the input navigation segment.
+     *  The path consists of a horizontal segment followed by a vertical segment, or vice versa,
+     *  depending on the relative distances between the x and z coordinates of the points.
+     * @param navSegment An array of BABYLON.Vector3 points representing the navigation segment.
+     * @returns An array of BABYLON.Vector3 points representing the L-shaped path.
      */
-    private _createMultiScatteringEffectWrapper;
+    export function GetLShapedPath(navSegment: BABYLON.Vector3[]): BABYLON.Vector3[];
+
+
     /**
-     * Draws the multiple scattering LUT using {@link EffectWrapper} and {@link EffectRenderer}.
+     * Creates a default tile cache mesh process function
+     * @param offMeshConnections offMeshConnections
+     * @param area the area to be set for each poly
+     * @param flags the flags to be set for each poly
+     * @returns the tile cache mesh process function
      */
-    private _drawMultiScatteringLut;
+    export function CreateDefaultTileCacheMeshProcess(offMeshConnections?: any, area?: number, flags?: number): any;
     /**
-     * Draws the aerial perspective compositor using {@link EffectWrapper} and {@link EffectRenderer}.
+     * Waits until the tile cache is fully updated
+     * @param navMesh The any
+     * @param tileCache THe any
      */
-    drawAerialPerspectiveCompositor(): void;
+    export function WaitForFullTileCacheUpdate(navMesh: any, tileCache: any): void;
+
+
     /**
-     * Draws the sky compositor using {@link EffectWrapper} and {@link EffectRenderer}.
+     * Compute a smooth navigation path from start to end. Returns an empty array if no path can be computed
+     * @param navMesh the navigation mesh to use
+     * @param navmeshQuery the navigation mesh query to use
+     * @param start world position
+     * @param end world position
+     * @param options options object
+     * @returns array containing world position composing the path
      */
-    drawSkyCompositor(): void;
+    export function ComputeSmoothPath(navMesh: any, navmeshQuery: any, start: BABYLON.IVector3Like, end: BABYLON.IVector3Like, options?: {
+        filter?: any;
+        halfExtents?: BABYLON.IVector3Like;
+        /**
+         * @default 256
+         */
+        maxPathPolys?: number;
+        /**
+         * @default 2048
+         */
+        maxSmoothPathPoints?: number;
+        /**
+         * @default 0.5
+         */
+        stepSize?: number;
+        /**
+         * @default 0.01
+         */
+        slop?: number;
+    }): BABYLON.Vector3[];
+
+
+
+
     /**
-     * Draws the globe atmosphere compositor using {@link EffectWrapper} and {@link EffectRenderer}.
+     *  Extracts positions and indices from an array of meshes.
+     *  @param meshes The array of meshes from which to extract positions and indices.
+     *  @returns A tuple containing a Float32Array of positions and a Uint32Array of
      */
-    drawGlobeAtmosphereCompositor(): void;
-    private _disposeSkyCompositor;
-    private _disposeAerialPerspectiveCompositor;
-    private _disposeGlobeAtmosphereCompositor;
+    export function GetPositionsAndIndices(meshes: BABYLON.Mesh[]): [positions: Float32Array, indices: Uint32Array];
     /**
-     * Updates the camera variables that are specific to the atmosphere.
-     * @param camera - The camera to update the variables for.
+     * Reverses the order of vertices in each triangle (3 indices per face) to ensure
+     * that the winding order is consistent with the Recast Navigation requirements.
+     * This is necessary because Recast Navigation expects the indices to be in a specific winding order.
+     * @param meshOrIndices The mesh from which to extract indices or the indices themselves.
+     * @returns Array of indices with reversed winding order.
      */
-    private _updatePerCameraVariables;
+    export function GetReversedIndices(meshOrIndices: BABYLON.Mesh | Uint32Array | number[]): Uint32Array<ArrayBufferLike> | number[] | Int32Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | null;
+
+
     /**
-     * Renders the lookup tables, some of which can vary per-camera.
-     * It is expected that updatePerCameraVariables was previously called.
+     *  Converts navigation path points to a BABYLON.Vector3 array.
+     *  @param navPath The navigation path containing points and success status.
+     *  @returns An array of BABYLON.Vector3 points representing the navigation path.
      */
-    private _renderLutsForCamera;
+    export function ConvertNavPathPoints(navPath: ComputePathResult): BABYLON.Vector3[];
+
+
+    export const DefaultMaxObstacles = 128;
     /**
-     * Renders the lookup tables that do not depend on a camera position.
+     * Creates a SoloNavMesh configuration based on the provided parameters.
+     * @param parameters The parameters used to configure the SoloNavMesh generation.
+     * @returns A configuration object for generating a SoloNavMesh.
+     * @see https://docs.recast-navigation-js.isaacmason.com/types/index.RecastConfig.html
      */
-    renderGlobalLuts(): void;
+    export function CreateSoloNavMeshConfig(parameters: INavMeshParametersV2): Partial<any>;
     /**
-     * Binds the atmosphere's uniform buffer to an {@link Effect}.
-     * @param effect - The {@link Effect} to bind the uniform buffer to.
+     * Creates a TiledNavMesh configuration based on the provided parameters.
+     * @param parameters The parameters used to configure the TiledNavMesh generation.
+     * @returns A configuration object for generating a TiledNavMesh.
      */
-    bindUniformBufferToEffect(effect: Effect): void;
+    export function CreateTiledNavMeshConfig(parameters: INavMeshParametersV2): Partial<any>;
     /**
-     * Updates the atmosphere's uniform buffer.
+     * Creates a TileCacheNavMesh configuration based on the provided parameters.
+     * @param parameters The parameters used to configure the TileCacheNavMesh generation.
+     * @returns A configuration object for generating a TileCacheNavMesh.
      */
-    updateUniformBuffer(): void;
+    export function CreateTileCacheNavMeshConfig(parameters: INavMeshParametersV2): Partial<any>;
     /**
-     * Draws the aerial perspective LUT using {@link EffectWrapper} and {@link EffectRenderer}.
+     * Convert IAgentParameters to Recast any
+     * @param config Agent parameters
+     * @returns Recast crowd agent paramaters
      */
-    private _drawAerialPerspectiveLut;
+    export function ToSoloNavMeshGeneratorConfig(config: INavMeshParametersV2): Partial<any>;
     /**
-     * Draws the sky view LUT using {@link EffectWrapper} and {@link EffectRenderer}.
+     * Convert IAgentParameters to Recast any
+     * @param agentParams Agent parameters
+     * @returns Recast crowd agent paramaters
      */
-    private _drawSkyViewLut;
-}
-
-}
-declare module "babylonjs-addons/atmosphere/test/unit/sampling.test" {
-export {};
-
-}
-declare module "babylonjs-addons/atmosphere/Shaders/transmittance.fragment" {
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
-import "babylonjs/Shaders/ShadersInclude/helperFunctions";
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions";
-/** @internal */
-export const transmittancePixelShader: {
-    name: string;
-    shader: string;
-};
-
-}
-declare module "babylonjs-addons/atmosphere/Shaders/skyView.fragment" {
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
-import "babylonjs/Shaders/ShadersInclude/helperFunctions";
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions";
-/** @internal */
-export const skyViewPixelShader: {
-    name: string;
-    shader: string;
-};
-
-}
-declare module "babylonjs-addons/atmosphere/Shaders/multiScattering.fragment" {
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
-import "babylonjs/Shaders/ShadersInclude/helperFunctions";
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions";
-/** @internal */
-export const multiScatteringPixelShader: {
-    name: string;
-    shader: string;
-};
-
-}
-declare module "babylonjs-addons/atmosphere/Shaders/fullscreenTriangle.vertex" {
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
-/** @internal */
-export const fullscreenTriangleVertexShader: {
-    name: string;
-    shader: string;
-};
-
-}
-declare module "babylonjs-addons/atmosphere/Shaders/diffuseSkyIrradiance.fragment" {
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
-import "babylonjs/Shaders/ShadersInclude/helperFunctions";
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/depthFunctions";
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions";
-import "babylonjs/Shaders/ShadersInclude/importanceSampling";
-import "babylonjs/Shaders/ShadersInclude/pbrBRDFFunctions";
-import "babylonjs/Shaders/ShadersInclude/hdrFilteringFunctions";
-/** @internal */
-export const diffuseSkyIrradiancePixelShader: {
-    name: string;
-    shader: string;
-};
-
-}
-declare module "babylonjs-addons/atmosphere/Shaders/compositeSky.fragment" {
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
-import "babylonjs/Shaders/ShadersInclude/helperFunctions";
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/depthFunctions";
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions";
-/** @internal */
-export const compositeSkyPixelShader: {
-    name: string;
-    shader: string;
-};
-
-}
-declare module "babylonjs-addons/atmosphere/Shaders/compositeGlobeAtmosphere.fragment" {
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
-import "babylonjs/Shaders/ShadersInclude/helperFunctions";
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/depthFunctions";
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions";
-/** @internal */
-export const compositeGlobeAtmospherePixelShader: {
-    name: string;
-    shader: string;
-};
-
-}
-declare module "babylonjs-addons/atmosphere/Shaders/compositeAerialPerspective.fragment" {
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
-import "babylonjs/Shaders/ShadersInclude/helperFunctions";
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/depthFunctions";
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions";
-/** @internal */
-export const compositeAerialPerspectivePixelShader: {
-    name: string;
-    shader: string;
-};
-
-}
-declare module "babylonjs-addons/atmosphere/Shaders/aerialPerspective.fragment" {
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
-import "babylonjs/Shaders/ShadersInclude/helperFunctions";
-import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions";
-/** @internal */
-export const aerialPerspectivePixelShader: {
-    name: string;
-    shader: string;
-};
-
-}
-declare module "babylonjs-addons/atmosphere/Shaders/ShadersInclude/depthFunctions" {
-/** @internal */
-export const depthFunctions: {
-    name: string;
-    shader: string;
-};
-
-}
-declare module "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereVertexDeclaration" {
-/** @internal */
-export const atmosphereVertexDeclaration: {
-    name: string;
-    shader: string;
-};
-
-}
-declare module "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration" {
-/** @internal */
-export const atmosphereUboDeclaration: {
-    name: string;
-    shader: string;
-};
-
-}
-declare module "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions" {
-import "babylonjs/Shaders/ShadersInclude/intersectionFunctions";
-/** @internal */
-export const atmosphereFunctions: {
-    name: string;
-    shader: string;
-};
-
-}
-declare module "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration" {
-/** @internal */
-export const atmosphereFragmentDeclaration: {
-    name: string;
-    shader: string;
-};
-
-}
-
-declare module "babylonjs-addons" {
-    export * from "babylonjs-addons/index";
-}
-
-
-declare module ADDONS {
+    export function ToCrowdAgentParams(agentParams: IAgentParametersV2): Partial<any>;
 
 
     /**
@@ -2130,6 +4871,18 @@ declare module ADDONS {
     }
 
 
+    export interface ISdfTextParagraphMetrics {
+        /** @internal */
+        readonly paragraph: string;
+        /** @internal */
+        readonly lines: SdfTextLine[];
+        /** @internal */
+        readonly width: number;
+        /** @internal */
+        readonly height: number;
+        /** @internal */
+        readonly glyphs: SdfGlyph[];
+    }
     /** @internal */
     export type ParagraphOptions = {
         maxWidth: number;
@@ -2139,6 +4892,7 @@ declare module ADDONS {
         whiteSpace: "pre-line";
         textAlign: "left" | "right" | "center";
         translate: BABYLON.IVector2Like | undefined;
+        customLayoutEngine?: (text: string, options: ParagraphOptions) => ISdfTextParagraphMetrics;
     };
     /** @internal */
     export var DefaultParagraphOptions: ParagraphOptions;